Imported Upstream version 3.12.0upstream/3.12.0

397 files changed, 11390 insertions, 7151 deletions

diff --git a/Source/CMakeInstallDestinations.cmake b/Source/CMakeInstallDestinations.cmake
index 28f4e87ad..e82bec3cd 100644
--- a/Source/CMakeInstallDestinations.cmake
+++ b/Source/CMakeInstallDestinations.cmake
@@ -2,19 +2,22 @@
 if(BEOS)
   set(CMAKE_BIN_DIR_DEFAULT "bin") # HAIKU
   set(CMAKE_DATA_DIR_DEFAULT "share/cmake-${CMake_VERSION_MAJOR}.${CMake_VERSION_MINOR}") # HAIKU
-  set(CMAKE_MAN_DIR_DEFAULT "documentation/man") # HAIKU
   set(CMAKE_DOC_DIR_DEFAULT "documentation/doc/cmake-${CMake_VERSION_MAJOR}.${CMake_VERSION_MINOR}") # HAIKU
+  set(CMAKE_INFO_DIR_DEFAULT "documentation/info") # HAIKU
+  set(CMAKE_MAN_DIR_DEFAULT "documentation/man") # HAIKU
   set(CMAKE_XDGDATA_DIR_DEFAULT "share") # HAIKU
 elseif(CYGWIN)
   set(CMAKE_BIN_DIR_DEFAULT "bin") # CYGWIN
   set(CMAKE_DATA_DIR_DEFAULT "share/cmake-${CMake_VERSION}") # CYGWIN
   set(CMAKE_DOC_DIR_DEFAULT "share/doc/cmake-${CMake_VERSION}") # CYGWIN
+  set(CMAKE_INFO_DIR_DEFAULT "share/info") # CYGWIN
   set(CMAKE_MAN_DIR_DEFAULT "share/man") # CYGWIN
   set(CMAKE_XDGDATA_DIR_DEFAULT "share") # CYGWIN
 else()
   set(CMAKE_BIN_DIR_DEFAULT "bin") # OTHER
   set(CMAKE_DATA_DIR_DEFAULT "share/cmake-${CMake_VERSION_MAJOR}.${CMake_VERSION_MINOR}") # OTHER
   set(CMAKE_DOC_DIR_DEFAULT "doc/cmake-${CMake_VERSION_MAJOR}.${CMake_VERSION_MINOR}") # OTHER
+  set(CMAKE_INFO_DIR_DEFAULT "info") # OTHER
   set(CMAKE_MAN_DIR_DEFAULT "man") # OTHER
   set(CMAKE_XDGDATA_DIR_DEFAULT "share") # OTHER
 endif()
@@ -22,6 +25,7 @@ endif()
 set(CMAKE_BIN_DIR_DESC "bin")
 set(CMAKE_DATA_DIR_DESC "data")
 set(CMAKE_DOC_DIR_DESC "docs")
+set(CMAKE_INFO_DIR_DESC "Info manual")
 set(CMAKE_MAN_DIR_DESC "man pages")
 set(CMAKE_XDGDATA_DIR_DESC "XDG specific files")
 
@@ -35,6 +39,7 @@ foreach(v
     CMAKE_BIN_DIR
     CMAKE_DATA_DIR
     CMAKE_DOC_DIR
+    CMAKE_INFO_DIR
     CMAKE_MAN_DIR
     CMAKE_XDGDATA_DIR
     )
diff --git a/Source/CMakeLists.txt b/Source/CMakeLists.txt
index 61327be7d..30bef744e 100644
--- a/Source/CMakeLists.txt
+++ b/Source/CMakeLists.txt
@@ -131,6 +131,8 @@ set(SRCS
   LexerParser/cmListFileLexer.c
   LexerParser/cmListFileLexer.in.l
 
+  cmAffinity.cxx
+  cmAffinity.h
   cmArchiveWrite.cxx
   cmBase32.cxx
   cmCacheManager.cxx
@@ -244,6 +246,8 @@ set(SRCS
   cmGlobalGeneratorFactory.h
   cmGlobalUnixMakefileGenerator3.cxx
   cmGlobalUnixMakefileGenerator3.h
+  cmGlobVerificationManager.cxx
+  cmGlobVerificationManager.h
   cmGraphAdjacencyList.h
   cmGraphVizWriter.cxx
   cmGraphVizWriter.h
@@ -371,6 +375,8 @@ set(SRCS
   cmCommand.h
   cmCommands.cxx
   cmCommands.h
+  cmAddCompileDefinitionsCommand.cxx
+  cmAddCompileDefinitionsCommand.h
   cmAddCompileOptionsCommand.cxx
   cmAddCompileOptionsCommand.h
   cmAddCustomCommandCommand.cxx
@@ -553,6 +559,7 @@ set(SRCS
   cmSiteNameCommand.h
   cmSourceGroupCommand.cxx
   cmSourceGroupCommand.h
+  cmStringReplaceHelper.cxx
   cmStringCommand.cxx
   cmStringCommand.h
   cmSubdirCommand.cxx
@@ -879,6 +886,7 @@ set(CPACK_SRCS
   CPack/cmCPackGenerator.cxx
   CPack/cmCPackLog.cxx
   CPack/cmCPackNSISGenerator.cxx
+  CPack/cmCPackNuGetGenerator.cxx
   CPack/cmCPackSTGZGenerator.cxx
   CPack/cmCPackTGZGenerator.cxx
   CPack/cmCPackTXZGenerator.cxx
diff --git a/Source/CMakeVersion.cmake b/Source/CMakeVersion.cmake
index d8059bf41..24f74e4b9 100644
--- a/Source/CMakeVersion.cmake
+++ b/Source/CMakeVersion.cmake
@@ -1,5 +1,5 @@
 # CMake version number components.
 set(CMake_VERSION_MAJOR 3)
-set(CMake_VERSION_MINOR 11)
-set(CMake_VERSION_PATCH 4)
+set(CMake_VERSION_MINOR 12)
+set(CMake_VERSION_PATCH 0)
 #set(CMake_VERSION_RC 0)
diff --git a/Source/CMakeVersionCompute.cmake b/Source/CMakeVersionCompute.cmake
index 79264ed37..72a580058 100644
--- a/Source/CMakeVersionCompute.cmake
+++ b/Source/CMakeVersionCompute.cmake
@@ -32,7 +32,12 @@ endif()
 # components in the RC file are 16-bit integers so we may have to
 # split the patch component.
 if(CMake_VERSION_PATCH MATCHES "^([0-9]+)([0-9][0-9][0-9][0-9])$")
-  set(CMake_RCVERSION ${CMake_VERSION_MAJOR},${CMake_VERSION_MINOR},${CMAKE_MATCH_1},${CMAKE_MATCH_2})
+  set(CMake_RCVERSION_YEAR "${CMAKE_MATCH_1}")
+  set(CMake_RCVERSION_MONTH_DAY "${CMAKE_MATCH_2}")
+  string(REGEX REPLACE "^0+" "" CMake_RCVERSION_MONTH_DAY "${CMake_RCVERSION_MONTH_DAY}")
+  set(CMake_RCVERSION ${CMake_VERSION_MAJOR},${CMake_VERSION_MINOR},${CMake_RCVERSION_YEAR},${CMake_RCVERSION_MONTH_DAY})
+  unset(CMake_RCVERSION_MONTH_DAY)
+  unset(CMake_RCVERSION_YEAR)
 else()
   set(CMake_RCVERSION ${CMake_VERSION_MAJOR},${CMake_VERSION_MINOR},${CMake_VERSION_PATCH})
 endif()
diff --git a/Source/CPack/IFW/cmCPackIFWGenerator.cxx b/Source/CPack/IFW/cmCPackIFWGenerator.cxx
index 9f1a15e25..cf8334aef 100644
--- a/Source/CPack/IFW/cmCPackIFWGenerator.cxx
+++ b/Source/CPack/IFW/cmCPackIFWGenerator.cxx
@@ -61,7 +61,8 @@ int cmCPackIFWGenerator::PackageFiles()
           ifwCmd += " --repository " + rd;
         }
       } else {
-        cmCPackIFWLogger(WARNING, "The \"CPACK_IFW_REPOSITORIES_DIRECTORIES\" "
+        cmCPackIFWLogger(WARNING,
+                         "The \"CPACK_IFW_REPOSITORIES_DIRECTORIES\" "
                            << "variable is set, but content will be skipped, "
                            << "because this feature available only since "
                            << "QtIFW 3.1. Please update your QtIFW instance."
@@ -93,7 +94,8 @@ int cmCPackIFWGenerator::PackageFiles()
       ofs << "# Run command: " << ifwCmd << std::endl
           << "# Output:" << std::endl
           << output << std::endl;
-      cmCPackIFWLogger(ERROR, "Problem running IFW command: "
+      cmCPackIFWLogger(ERROR,
+                       "Problem running IFW command: "
                          << ifwCmd << std::endl
                          << "Please check " << ifwTmpFile << " for errors"
                          << std::endl);
@@ -102,15 +104,16 @@ int cmCPackIFWGenerator::PackageFiles()
 
     if (!this->Repository.RepositoryUpdate.empty() &&
         !this->Repository.PatchUpdatesXml()) {
-      cmCPackIFWLogger(WARNING, "Problem patch IFW \"Updates\" "
+      cmCPackIFWLogger(WARNING,
+                       "Problem patch IFW \"Updates\" "
                          << "file: "
                          << this->toplevel + "/repository/Updates.xml"
                          << std::endl);
     }
 
-    cmCPackIFWLogger(OUTPUT, "- repository: " << this->toplevel
-                                              << "/repository generated"
-                                              << std::endl);
+    cmCPackIFWLogger(OUTPUT,
+                     "- repository: " << this->toplevel
+                                      << "/repository generated" << std::endl);
   }
 
   // Run binary creator
@@ -145,7 +148,8 @@ int cmCPackIFWGenerator::PackageFiles()
           ifwCmd += " --repository " + rd;
         }
       } else {
-        cmCPackIFWLogger(WARNING, "The \"CPACK_IFW_REPOSITORIES_DIRECTORIES\" "
+        cmCPackIFWLogger(WARNING,
+                         "The \"CPACK_IFW_REPOSITORIES_DIRECTORIES\" "
                            << "variable is set, but content will be skipped, "
                            << "because this feature available only since "
                            << "QtIFW 3.1. Please update your QtIFW instance."
@@ -203,7 +207,8 @@ int cmCPackIFWGenerator::PackageFiles()
       ofs << "# Run command: " << ifwCmd << std::endl
           << "# Output:" << std::endl
           << output << std::endl;
-      cmCPackIFWLogger(ERROR, "Problem running IFW command: "
+      cmCPackIFWLogger(ERROR,
+                       "Problem running IFW command: "
                          << ifwCmd << std::endl
                          << "Please check " << ifwTmpFile << " for errors"
                          << std::endl);
@@ -257,8 +262,9 @@ int cmCPackIFWGenerator::InitializeInternal()
   }
 
   if (this->BinCreator.empty()) {
-    cmCPackIFWLogger(ERROR, "Cannot find QtIFW compiler \"binarycreator\": "
-                            "likely it is not installed, or not in your PATH"
+    cmCPackIFWLogger(ERROR,
+                     "Cannot find QtIFW compiler \"binarycreator\": "
+                     "likely it is not installed, or not in your PATH"
                        << std::endl);
     return 0;
   }
@@ -415,7 +421,8 @@ cmCPackComponent* cmCPackIFWGenerator::GetComponent(
     }
   } else {
     this->Packages.erase(name);
-    cmCPackIFWLogger(ERROR, "Cannot configure package \""
+    cmCPackIFWLogger(ERROR,
+                     "Cannot configure package \""
                        << name << "\" for component \"" << component->Name
                        << "\"" << std::endl);
   }
@@ -450,7 +457,8 @@ cmCPackComponentGroup* cmCPackIFWGenerator::GetComponentGroup(
     this->BinaryPackages.insert(package);
   } else {
     this->Packages.erase(name);
-    cmCPackIFWLogger(ERROR, "Cannot configure package \""
+    cmCPackIFWLogger(ERROR,
+                     "Cannot configure package \""
                        << name << "\" for component group \"" << group->Name
                        << "\"" << std::endl);
   }
@@ -596,7 +604,8 @@ cmCPackIFWRepository* cmCPackIFWGenerator::GetRepository(
   } else {
     this->Repositories.erase(repositoryName);
     repository = nullptr;
-    cmCPackIFWLogger(WARNING, "Invalid repository \""
+    cmCPackIFWLogger(WARNING,
+                     "Invalid repository \""
                        << repositoryName << "\""
                        << " configuration. Repository will be skipped."
                        << std::endl);
diff --git a/Source/CPack/IFW/cmCPackIFWGenerator.h b/Source/CPack/IFW/cmCPackIFWGenerator.h
index 919dd4678..0430122c9 100644
--- a/Source/CPack/IFW/cmCPackIFWGenerator.h
+++ b/Source/CPack/IFW/cmCPackIFWGenerator.h
@@ -22,7 +22,9 @@
  *
  * http://qt-project.org/doc/qtinstallerframework/index.html
  */
-class cmCPackIFWGenerator : public cmCPackGenerator, public cmCPackIFWCommon
+class cmCPackIFWGenerator
+  : public cmCPackGenerator
+  , public cmCPackIFWCommon
 {
 public:
   cmCPackTypeMacro(cmCPackIFWGenerator, cmCPackGenerator);
diff --git a/Source/CPack/IFW/cmCPackIFWInstaller.cxx b/Source/CPack/IFW/cmCPackIFWInstaller.cxx
index 05a852d1d..36cf08cfc 100644
--- a/Source/CPack/IFW/cmCPackIFWInstaller.cxx
+++ b/Source/CPack/IFW/cmCPackIFWInstaller.cxx
@@ -24,7 +24,8 @@ void cmCPackIFWInstaller::printSkippedOptionWarning(
   const std::string& optionName, const std::string& optionValue)
 {
   cmCPackIFWLogger(
-    WARNING, "Option "
+    WARNING,
+    "Option "
       << optionName << " is set to \"" << optionValue
       << "\" but will be skipped because the specified file does not exist."
       << std::endl);
@@ -146,7 +147,8 @@ void cmCPackIFWInstaller::ConfigureFromOptions()
     if (this->WizardStyle != "Modern" && this->WizardStyle != "Aero" &&
         this->WizardStyle != "Mac" && this->WizardStyle != "Classic") {
       cmCPackIFWLogger(
-        WARNING, "Option CPACK_IFW_PACKAGE_WIZARD_STYLE has unknown value \""
+        WARNING,
+        "Option CPACK_IFW_PACKAGE_WIZARD_STYLE has unknown value \""
           << option << "\". Expected values are: Modern, Aero, Mac, Classic."
           << std::endl);
     }
@@ -469,7 +471,8 @@ void cmCPackIFWInstaller::GenerateInstallerFile()
         cmsys::SystemTools::CopyFileIfDifferent(this->Resources[i], path);
         resources.push_back(std::move(name));
       } else {
-        cmCPackIFWLogger(WARNING, "Can't copy resources from \""
+        cmCPackIFWLogger(WARNING,
+                         "Can't copy resources from \""
                            << this->Resources[i]
                            << "\". Resource will be skipped." << std::endl);
       }
diff --git a/Source/CPack/IFW/cmCPackIFWPackage.cxx b/Source/CPack/IFW/cmCPackIFWPackage.cxx
index d3ce15c86..f24ab6997 100644
--- a/Source/CPack/IFW/cmCPackIFWPackage.cxx
+++ b/Source/CPack/IFW/cmCPackIFWPackage.cxx
@@ -126,10 +126,10 @@ void cmCPackIFWPackage::DefaultConfiguration()
   this->RequiresAdminRights.clear();
 }
 
-// Defaul configuration (all in one package)
+// Default configuration (all in one package)
 int cmCPackIFWPackage::ConfigureFromOptions()
 {
-  // Restore defaul configuration
+  // Restore default configuration
   this->DefaultConfiguration();
 
   // Name
@@ -168,7 +168,7 @@ int cmCPackIFWPackage::ConfigureFromComponent(cmCPackComponent* component)
     return 0;
   }
 
-  // Restore defaul configuration
+  // Restore default configuration
   this->DefaultConfiguration();
 
   std::string prefix = "CPACK_IFW_COMPONENT_" +
@@ -226,7 +226,8 @@ int cmCPackIFWPackage::ConfigureFromComponent(cmCPackComponent* component)
   if (const char* option = this->GetOption(prefix + "PRIORITY")) {
     this->SortingPriority = option;
     cmCPackIFWLogger(
-      WARNING, "The \"PRIORITY\" option is set "
+      WARNING,
+      "The \"PRIORITY\" option is set "
         << "for component \"" << component->Name << "\", but there option is "
         << "deprecated. Please use \"SORTING_PRIORITY\" option instead."
         << std::endl);
@@ -255,7 +256,7 @@ int cmCPackIFWPackage::ConfigureFromGroup(cmCPackComponentGroup* group)
     return 0;
   }
 
-  // Restore defaul configuration
+  // Restore default configuration
   this->DefaultConfiguration();
 
   std::string prefix = "CPACK_IFW_COMPONENT_GROUP_" +
@@ -303,7 +304,8 @@ int cmCPackIFWPackage::ConfigureFromGroup(cmCPackComponentGroup* group)
   if (const char* option = this->GetOption(prefix + "PRIORITY")) {
     this->SortingPriority = option;
     cmCPackIFWLogger(
-      WARNING, "The \"PRIORITY\" option is set "
+      WARNING,
+      "The \"PRIORITY\" option is set "
         << "for component group \"" << group->Name
         << "\", but there option is "
         << "deprecated. Please use \"SORTING_PRIORITY\" option instead."
diff --git a/Source/CPack/WiX/cmCMakeToWixPath.cxx b/Source/CPack/WiX/cmCMakeToWixPath.cxx
index 0b0e42aa9..b3889cf2e 100644
--- a/Source/CPack/WiX/cmCMakeToWixPath.cxx
+++ b/Source/CPack/WiX/cmCMakeToWixPath.cxx
@@ -8,7 +8,7 @@
 #include <vector>
 
 #ifdef __CYGWIN__
-#include <sys/cygwin.h>
+#  include <sys/cygwin.h>
 std::string CMakeToWixPath(const std::string& cygpath)
 {
   std::vector<char> winpath_chars;
diff --git a/Source/CPack/WiX/cmCPackWIXGenerator.cxx b/Source/CPack/WiX/cmCPackWIXGenerator.cxx
index a0bc0eabd..e06efdafd 100644
--- a/Source/CPack/WiX/cmCPackWIXGenerator.cxx
+++ b/Source/CPack/WiX/cmCPackWIXGenerator.cxx
@@ -23,9 +23,9 @@
 #include "cmsys/SystemTools.hxx"
 
 #ifdef _WIN32
-#include <rpc.h> // for GUID generation (windows only)
+#  include <rpc.h> // for GUID generation (windows only)
 #else
-#include <uuid/uuid.h> // for GUID generation (libuuid)
+#  include <uuid/uuid.h> // for GUID generation (libuuid)
 #endif
 
 #include "cmCMakeToWixPath.h"
@@ -55,8 +55,8 @@ 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;
 
@@ -71,8 +71,9 @@ bool cmCPackWIXGenerator::RunWiXCommand(std::string const& command)
   logFile.close();
 
   if (!status || returnValue) {
-    cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem running WiX candle. "
-                                         "Please check '"
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Problem running WiX candle. "
+                  "Please check '"
                     << logFileName << "' for errors." << std::endl);
 
     return false;
@@ -137,8 +138,8 @@ bool cmCPackWIXGenerator::RunLightCommand(std::string const& objectFiles)
 int cmCPackWIXGenerator::PackageFiles()
 {
   if (!PackageFilesImpl() || cmSystemTools::GetErrorOccuredFlag()) {
-    cmCPackLogger(cmCPackLog::LOG_ERROR, "Fatal WiX Generator Error"
-                    << std::endl);
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Fatal WiX Generator Error" << std::endl);
     return false;
   }
 
@@ -148,8 +149,8 @@ int cmCPackWIXGenerator::PackageFiles()
 bool cmCPackWIXGenerator::InitializeWiXConfiguration()
 {
   if (!ReadListFile("CPackWIX.cmake")) {
-    cmCPackLogger(cmCPackLog::LOG_ERROR, "Error while executing CPackWIX.cmake"
-                    << std::endl);
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Error while executing CPackWIX.cmake" << std::endl);
     return false;
   }
 
@@ -166,12 +167,13 @@ bool cmCPackWIXGenerator::InitializeWiXConfiguration()
     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)) {
@@ -370,8 +372,9 @@ void cmCPackWIXGenerator::CreateWiXPropertiesIncludeFile()
     includeFile.AddAttribute("Id", "FindInstallLocation");
     includeFile.AddAttribute("Root", "HKLM");
     includeFile.AddAttribute(
-      "Key", "Software\\Microsoft\\Windows\\"
-             "CurrentVersion\\Uninstall\\[WIX_UPGRADE_DETECTED]");
+      "Key",
+      "Software\\Microsoft\\Windows\\"
+      "CurrentVersion\\Uninstall\\[WIX_UPGRADE_DETECTED]");
     includeFile.AddAttribute("Name", "InstallLocation");
     includeFile.AddAttribute("Type", "raw");
     includeFile.EndElement("RegistrySearch");
@@ -613,8 +616,9 @@ bool cmCPackWIXGenerator::GenerateMainSourceFileFromTemplate()
   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);
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Failed creating '" << mainSourceFilePath
+                                      << "'' from template." << std::endl);
 
     return false;
   }
@@ -957,8 +961,8 @@ bool cmCPackWIXGenerator::RequireOption(std::string const& name,
 
     return true;
   } else {
-    cmCPackLogger(cmCPackLog::LOG_ERROR, "Required variable "
-                    << name << " not set" << std::endl);
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Required variable " << name << " not set" << std::endl);
 
     return false;
   }
diff --git a/Source/CPack/WiX/cmWIXAccessControlList.cxx b/Source/CPack/WiX/cmWIXAccessControlList.cxx
index 1603bf868..563de02ae 100644
--- a/Source/CPack/WiX/cmWIXAccessControlList.cxx
+++ b/Source/CPack/WiX/cmWIXAccessControlList.cxx
@@ -66,8 +66,9 @@ void cmWIXAccessControlList::CreatePermissionElement(std::string const& entry)
 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)
diff --git a/Source/CPack/WiX/cmWIXPatch.cxx b/Source/CPack/WiX/cmWIXPatch.cxx
index dec95fb6e..ca232f94b 100644
--- a/Source/CPack/WiX/cmWIXPatch.cxx
+++ b/Source/CPack/WiX/cmWIXPatch.cxx
@@ -13,8 +13,9 @@ 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);
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Failed parsing XML patch file: '" << patchFilePath << "'"
+                                                     << std::endl);
     return false;
   }
 
diff --git a/Source/CPack/WiX/cmWIXSourceWriter.cxx b/Source/CPack/WiX/cmWIXSourceWriter.cxx
index dc730e00c..6adf80bac 100644
--- a/Source/CPack/WiX/cmWIXSourceWriter.cxx
+++ b/Source/CPack/WiX/cmWIXSourceWriter.cxx
@@ -32,7 +32,8 @@ cmWIXSourceWriter::cmWIXSourceWriter(cmCPackLog* logger,
 cmWIXSourceWriter::~cmWIXSourceWriter()
 {
   if (Elements.size() > 1) {
-    cmCPackLogger(cmCPackLog::LOG_ERROR, Elements.size() - 1
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  Elements.size() - 1
                     << " WiX elements were still open when closing '"
                     << SourceFilename << "'" << std::endl);
     return;
@@ -65,7 +66,8 @@ void cmWIXSourceWriter::EndElement(std::string const& name)
   }
 
   if (Elements.back() != name) {
-    cmCPackLogger(cmCPackLog::LOG_ERROR, "WiX element <"
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "WiX element <"
                     << Elements.back() << "> can not be closed by </" << name
                     << "> in '" << SourceFilename << "'" << std::endl);
     return;
diff --git a/Source/CPack/cmCPackArchiveGenerator.cxx b/Source/CPack/cmCPackArchiveGenerator.cxx
index 9ff547a49..b734bb460 100644
--- a/Source/CPack/cmCPackArchiveGenerator.cxx
+++ b/Source/CPack/cmCPackArchiveGenerator.cxx
@@ -9,6 +9,7 @@
 #include "cmSystemTools.h"
 #include "cmWorkingDirectory.h"
 
+#include <cstring>
 #include <ostream>
 #include <utility>
 #include <vector>
@@ -51,6 +52,7 @@ int cmCPackArchiveGenerator::InitializeInternal()
   this->SetOptionIfNotSet("CPACK_INCLUDE_TOPLEVEL_DIRECTORY", "1");
   return this->Superclass::InitializeInternal();
 }
+
 int cmCPackArchiveGenerator::addOneComponentToArchive(
   cmArchiveWrite& archive, cmCPackComponent* component)
 {
@@ -61,6 +63,13 @@ int cmCPackArchiveGenerator::addOneComponentToArchive(
   localToplevel += "/" + component->Name;
   // Change to local toplevel
   cmWorkingDirectory workdir(localToplevel);
+  if (workdir.Failed()) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Failed to change working directory to "
+                    << localToplevel << " : "
+                    << std::strerror(workdir.GetLastResult()) << std::endl);
+    return 0;
+  }
   std::string filePrefix;
   if (this->IsOn("CPACK_COMPONENT_INCLUDE_TOPLEVEL_DIRECTORY")) {
     filePrefix = this->GetOption("CPACK_PACKAGE_FILE_NAME");
@@ -78,8 +87,9 @@ int cmCPackArchiveGenerator::addOneComponentToArchive(
     cmCPackLogger(cmCPackLog::LOG_DEBUG, "Adding file: " << rp << std::endl);
     archive.Add(rp, 0, nullptr, false);
     if (!archive) {
-      cmCPackLogger(cmCPackLog::LOG_ERROR, "ERROR while packaging files: "
-                      << archive.GetError() << std::endl);
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "ERROR while packaging files: " << archive.GetError()
+                                                    << std::endl);
       return 0;
     }
   }
@@ -102,7 +112,8 @@ int cmCPackArchiveGenerator::addOneComponentToArchive(
   }                                                                           \
   cmArchiveWrite archive(gf, this->Compress, this->ArchiveFormat);            \
   if (!(archive)) {                                                           \
-    cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem to create archive < "       \
+    cmCPackLogger(cmCPackLog::LOG_ERROR,                                      \
+                  "Problem to create archive < "                              \
                     << (filename) << ">. ERROR =" << (archive).GetError()     \
                     << std::endl);                                            \
     return 0;                                                                 \
@@ -139,7 +150,8 @@ int cmCPackArchiveGenerator::PackageComponents(bool ignoreGroup)
       // Does the component belong to a group?
       if (comp.second.Group == nullptr) {
         cmCPackLogger(
-          cmCPackLog::LOG_VERBOSE, "Component <"
+          cmCPackLog::LOG_VERBOSE,
+          "Component <"
             << comp.second.Name
             << "> does not belong to any group, package it separately."
             << std::endl);
@@ -237,12 +249,20 @@ int cmCPackArchiveGenerator::PackageFiles()
   // CASE 3 : NON COMPONENT package.
   DECLARE_AND_OPEN_ARCHIVE(packageFileNames[0], archive);
   cmWorkingDirectory workdir(toplevel);
+  if (workdir.Failed()) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Failed to change working directory to "
+                    << toplevel << " : "
+                    << std::strerror(workdir.GetLastResult()) << std::endl);
+    return 0;
+  }
   for (std::string const& file : files) {
     // Get the relative path to the file
     std::string rp = cmSystemTools::RelativePath(toplevel, file);
     archive.Add(rp, 0, nullptr, false);
     if (!archive) {
-      cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem while adding file< "
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "Problem while adding file< "
                       << file << "> to archive <" << packageFileNames[0]
                       << "> .ERROR =" << archive.GetError() << std::endl);
       return 0;
diff --git a/Source/CPack/cmCPackBundleGenerator.cxx b/Source/CPack/cmCPackBundleGenerator.cxx
index f47ca7a74..f8fd108d3 100644
--- a/Source/CPack/cmCPackBundleGenerator.cxx
+++ b/Source/CPack/cmCPackBundleGenerator.cxx
@@ -32,8 +32,8 @@ int cmCPackBundleGenerator::InitializeInternal()
       "codesign", std::vector<std::string>(), false);
 
     if (codesign_path.empty()) {
-      cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot locate codesign command"
-                      << std::endl);
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "Cannot locate codesign command" << std::endl);
       return 0;
     }
     this->SetOptionIfNotSet("CPACK_COMMAND_CODESIGN", codesign_path.c_str());
@@ -59,8 +59,8 @@ int cmCPackBundleGenerator::ConstructBundle()
     ? this->GetOption("CPACK_BUNDLE_NAME")
     : "";
   if (cpack_bundle_name.empty()) {
-    cmCPackLogger(cmCPackLog::LOG_ERROR, "CPACK_BUNDLE_NAME must be set."
-                    << std::endl);
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "CPACK_BUNDLE_NAME must be set." << std::endl);
 
     return 0;
   }
@@ -69,8 +69,8 @@ int cmCPackBundleGenerator::ConstructBundle()
     ? this->GetOption("CPACK_BUNDLE_PLIST")
     : "";
   if (cpack_bundle_plist.empty()) {
-    cmCPackLogger(cmCPackLog::LOG_ERROR, "CPACK_BUNDLE_PLIST must be set."
-                    << std::endl);
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "CPACK_BUNDLE_PLIST must be set." << std::endl);
 
     return 0;
   }
@@ -79,8 +79,8 @@ int cmCPackBundleGenerator::ConstructBundle()
     ? this->GetOption("CPACK_BUNDLE_ICON")
     : "";
   if (cpack_bundle_icon.empty()) {
-    cmCPackLogger(cmCPackLog::LOG_ERROR, "CPACK_BUNDLE_ICON must be set."
-                    << std::endl);
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "CPACK_BUNDLE_ICON must be set." << std::endl);
 
     return 0;
   }
@@ -269,8 +269,8 @@ int cmCPackBundleGenerator::SignBundle(const std::string& src_dir)
       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"
diff --git a/Source/CPack/cmCPackCygwinSourceGenerator.cxx b/Source/CPack/cmCPackCygwinSourceGenerator.cxx
index 2c289f668..889f29a59 100644
--- a/Source/CPack/cmCPackCygwinSourceGenerator.cxx
+++ b/Source/CPack/cmCPackCygwinSourceGenerator.cxx
@@ -15,8 +15,8 @@
 // system tools because it is not implemented robustly enough to move
 // files across directories.
 #ifdef _WIN32
-#include "cm_sys_stat.h"
-#include <windows.h>
+#  include "cm_sys_stat.h"
+#  include <windows.h>
 #endif
 
 cmCPackCygwinSourceGenerator::cmCPackCygwinSourceGenerator()
@@ -73,7 +73,8 @@ int cmCPackCygwinSourceGenerator::PackageFiles()
   if (!cmSystemTools::CopyFileAlways(
         this->GetOption("CPACK_CYGWIN_PATCH_FILE"),
         this->GetOption("CPACK_TOPLEVEL_DIRECTORY"))) {
-    cmCPackLogger(cmCPackLog::LOG_ERROR, "problem copying: ["
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "problem copying: ["
                     << this->GetOption("CPACK_CYGWIN_PATCH_FILE") << "]\nto\n["
                     << this->GetOption("CPACK_TOPLEVEL_DIRECTORY") << "]\n");
     return 0;
@@ -87,7 +88,8 @@ int cmCPackCygwinSourceGenerator::PackageFiles()
   if (!cmSystemTools::CopyFileAlways(
         this->GetOption("CPACK_CYGWIN_BUILD_SCRIPT"),
         this->GetOption("CPACK_TOPLEVEL_DIRECTORY"))) {
-    cmCPackLogger(cmCPackLog::LOG_ERROR, "problem copying: "
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "problem copying: "
                     << this->GetOption("CPACK_CYGWIN_BUILD_SCRIPT") << "\nto\n"
                     << this->GetOption("CPACK_TOPLEVEL_DIRECTORY") << "]\n");
     return 0;
@@ -96,7 +98,8 @@ int cmCPackCygwinSourceGenerator::PackageFiles()
   outerTarFile += "-";
   const char* patch = this->GetOption("CPACK_CYGWIN_PATCH_NUMBER");
   if (!patch) {
-    cmCPackLogger(cmCPackLog::LOG_WARNING, "CPACK_CYGWIN_PATCH_NUMBER"
+    cmCPackLogger(cmCPackLog::LOG_WARNING,
+                  "CPACK_CYGWIN_PATCH_NUMBER"
                     << " not specified, defaulting to 1\n");
     patch = "1";
   }
@@ -147,7 +150,8 @@ const char* cmCPackCygwinSourceGenerator::GetOutputExtension()
   this->OutputExtension = "-";
   const char* patch = this->GetOption("CPACK_CYGWIN_PATCH_NUMBER");
   if (!patch) {
-    cmCPackLogger(cmCPackLog::LOG_WARNING, "CPACK_CYGWIN_PATCH_NUMBER"
+    cmCPackLogger(cmCPackLog::LOG_WARNING,
+                  "CPACK_CYGWIN_PATCH_NUMBER"
                     << " not specified, defaulting to 1\n");
     patch = "1";
   }
diff --git a/Source/CPack/cmCPackDebGenerator.cxx b/Source/CPack/cmCPackDebGenerator.cxx
index 8ec54f88e..8a4c00427 100644
--- a/Source/CPack/cmCPackDebGenerator.cxx
+++ b/Source/CPack/cmCPackDebGenerator.cxx
@@ -62,8 +62,8 @@ int cmCPackDebGenerator::PackageOnePack(std::string const& initialTopLevel,
   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);
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Error while execution CPackDeb.cmake" << std::endl);
     retval = 0;
     return retval;
   }
@@ -115,7 +115,8 @@ int cmCPackDebGenerator::PackageComponents(bool ignoreGroup)
       // Does the component belong to a group?
       if (comp.second.Group == nullptr) {
         cmCPackLogger(
-          cmCPackLog::LOG_VERBOSE, "Component <"
+          cmCPackLog::LOG_VERBOSE,
+          "Component <"
             << comp.second.Name
             << "> does not belong to any group, package it separately."
             << std::endl);
@@ -179,8 +180,8 @@ int cmCPackDebGenerator::PackageComponentsAllInOne(
                     component_path.c_str());
   }
   if (!this->ReadListFile("CPackDeb.cmake")) {
-    cmCPackLogger(cmCPackLog::LOG_ERROR, "Error while execution CPackDeb.cmake"
-                    << std::endl);
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Error while execution CPackDeb.cmake" << std::endl);
     retval = 0;
     return retval;
   }
@@ -413,7 +414,8 @@ int cmCPackDebGenerator::createDeb()
     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 \""
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "Error opening the file \""
                       << filename_data_tar << "\" for writing" << std::endl);
       return 0;
     }
@@ -430,9 +432,9 @@ int cmCPackDebGenerator::createDeb()
     // e.g. /opt/bin/foo, /usr/bin/bar and /usr/bin/baz would
     // give /usr and /opt
     size_t topLevelLength = strGenWDIR.length();
-    cmCPackLogger(cmCPackLog::LOG_DEBUG, "WDIR: \""
-                    << strGenWDIR << "\", length = " << topLevelLength
-                    << std::endl);
+    cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                  "WDIR: \"" << strGenWDIR << "\", length = " << topLevelLength
+                             << std::endl);
     std::set<std::string> orderedFiles;
 
     // we have to reconstruct the parent folders as well
@@ -448,13 +450,13 @@ int cmCPackDebGenerator::createDeb()
     }
 
     for (std::string const& file : orderedFiles) {
-      cmCPackLogger(cmCPackLog::LOG_DEBUG, "FILEIT: \"" << file << "\""
-                                                        << std::endl);
+      cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                    "FILEIT: \"" << file << "\"" << std::endl);
       std::string::size_type slashPos = file.find('/', topLevelLength + 1);
       std::string relativeDir =
         file.substr(topLevelLength, slashPos - topLevelLength);
-      cmCPackLogger(cmCPackLog::LOG_DEBUG, "RELATIVEDIR: \""
-                      << relativeDir << "\"" << std::endl);
+      cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                    "RELATIVEDIR: \"" << relativeDir << "\"" << std::endl);
 
 #ifdef WIN32
       std::string mode_t_adt_filename = file + ":cmake_mode_t";
@@ -477,7 +479,8 @@ int cmCPackDebGenerator::createDeb()
 
       // do not recurse because the loop will do it
       if (!data_tar.Add(file, topLevelLength, ".", false)) {
-        cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem adding file to tar:"
+        cmCPackLogger(cmCPackLog::LOG_ERROR,
+                      "Problem adding file to tar:"
                         << std::endl
                         << "#top level directory: " << strGenWDIR << std::endl
                         << "#file: " << file << std::endl
@@ -505,8 +508,8 @@ int cmCPackDebGenerator::createDeb()
       std::string output =
         cmSystemTools::ComputeFileHash(file, cmCryptoHash::AlgoMD5);
       if (output.empty()) {
-        cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem computing the md5 of "
-                        << file << std::endl);
+        cmCPackLogger(cmCPackLog::LOG_ERROR,
+                      "Problem computing the md5 of " << file << std::endl);
       }
 
       output += "  " + file + "\n";
@@ -527,9 +530,10 @@ int cmCPackDebGenerator::createDeb()
     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);
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "Error opening the file \"" << filename_control_tar
+                                                << "\" for writing"
+                                                << std::endl);
       return 0;
     }
     cmArchiveWrite control_tar(fileStream_control_tar,
@@ -557,7 +561,8 @@ int cmCPackDebGenerator::createDeb()
     // 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:"
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "Error adding file to tar:"
                       << std::endl
                       << "#top level directory: " << strGenWDIR << std::endl
                       << "#file: \"control\" or \"md5sums\"" << std::endl
@@ -568,7 +573,8 @@ int cmCPackDebGenerator::createDeb()
     // adds generated shlibs file
     if (gen_shibs) {
       if (!control_tar.Add(shlibsfilename, strGenWDIR.length(), ".")) {
-        cmCPackLogger(cmCPackLog::LOG_ERROR, "Error adding file to tar:"
+        cmCPackLogger(cmCPackLog::LOG_ERROR,
+                      "Error adding file to tar:"
                         << std::endl
                         << "#top level directory: " << strGenWDIR << std::endl
                         << "#file: \"shlibs\"" << std::endl
@@ -581,7 +587,8 @@ int cmCPackDebGenerator::createDeb()
     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:"
+        cmCPackLogger(cmCPackLog::LOG_ERROR,
+                      "Error adding file to tar:"
                         << std::endl
                         << "#top level directory: " << strGenWDIR << std::endl
                         << "#file: \"postinst\"" << std::endl
@@ -594,7 +601,8 @@ int cmCPackDebGenerator::createDeb()
     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:"
+        cmCPackLogger(cmCPackLog::LOG_ERROR,
+                      "Error adding file to tar:"
                         << std::endl
                         << "#top level directory: " << strGenWDIR << std::endl
                         << "#file: \"postinst\"" << std::endl
@@ -656,10 +664,17 @@ int cmCPackDebGenerator::createDeb()
   cmGeneratedFileStream debStream;
   debStream.Open(outputPath.c_str(), false, true);
   cmArchiveWrite deb(debStream, cmArchiveWrite::CompressNone, "arbsd");
+
+  // uid/gid should be the one of the root user, and this root user has
+  // always uid/gid equal to 0.
+  deb.SetUIDAndGID(0u, 0u);
+  deb.SetUNAMEAndGNAME("root", "root");
+
   if (!deb.Add(tlDir + "debian-binary", tlDir.length()) ||
       !deb.Add(tlDir + "control.tar.gz", tlDir.length()) ||
       !deb.Add(tlDir + "data.tar" + compression_suffix, tlDir.length())) {
-    cmCPackLogger(cmCPackLog::LOG_ERROR, "Error creating debian package:"
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Error creating debian package:"
                     << std::endl
                     << "#top level directory: " << outputDir << std::endl
                     << "#file: " << outputName << std::endl
diff --git a/Source/CPack/cmCPackDragNDropGenerator.cxx b/Source/CPack/cmCPackDragNDropGenerator.cxx
index e95b96dfe..561652305 100644
--- a/Source/CPack/cmCPackDragNDropGenerator.cxx
+++ b/Source/CPack/cmCPackDragNDropGenerator.cxx
@@ -21,7 +21,7 @@
 // For the old LocaleStringToLangAndRegionCodes() function, to convert
 // to the old Script Manager RegionCode values needed for the 'LPic' data
 // structure used for generating multi-lingual SLAs.
-#include <CoreServices/CoreServices.h>
+#  include <CoreServices/CoreServices.h>
 #endif
 
 static const char* SLAHeader =
@@ -77,8 +77,8 @@ int cmCPackDragNDropGenerator::InitializeInternal()
   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);
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Cannot locate hdiutil command" << std::endl);
     return 0;
   }
   this->SetOptionIfNotSet("CPACK_COMMAND_HDIUTIL", hdiutil_path.c_str());
@@ -86,16 +86,16 @@ int cmCPackDragNDropGenerator::InitializeInternal()
   const std::string setfile_path =
     cmSystemTools::FindProgram("SetFile", paths, false);
   if (setfile_path.empty()) {
-    cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot locate SetFile command"
-                    << std::endl);
+    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);
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Cannot locate Rez command" << std::endl);
     return 0;
   }
   this->SetOptionIfNotSet("CPACK_COMMAND_REZ", rez_path.c_str());
@@ -124,8 +124,8 @@ int cmCPackDragNDropGenerator::InitializeInternal()
       return 0;
     }
     if (!cmSystemTools::FileExists(slaDirectory, false)) {
-      cmCPackLogger(cmCPackLog::LOG_ERROR, "CPACK_DMG_SLA_DIR does not exist"
-                      << std::endl);
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "CPACK_DMG_SLA_DIR does not exist" << std::endl);
       return 0;
     }
 
@@ -140,14 +140,16 @@ int cmCPackDragNDropGenerator::InitializeInternal()
     for (auto const& language : languages) {
       std::string license = slaDirectory + "/" + language + ".license.txt";
       if (!singleLicense && !cmSystemTools::FileExists(license)) {
-        cmCPackLogger(cmCPackLog::LOG_ERROR, "Missing license file "
-                        << language << ".license.txt" << std::endl);
+        cmCPackLogger(cmCPackLog::LOG_ERROR,
+                      "Missing license file " << language << ".license.txt"
+                                              << std::endl);
         return 0;
       }
       std::string menu = slaDirectory + "/" + language + ".menu.txt";
       if (!cmSystemTools::FileExists(menu)) {
-        cmCPackLogger(cmCPackLog::LOG_ERROR, "Missing menu file "
-                        << language << ".menu.txt" << std::endl);
+        cmCPackLogger(cmCPackLog::LOG_ERROR,
+                      "Missing menu file " << language << ".menu.txt"
+                                           << std::endl);
         return 0;
       }
     }
@@ -212,8 +214,9 @@ bool cmCPackDragNDropGenerator::CopyFile(std::ostringstream& source,
 {
   if (!cmSystemTools::CopyFileIfDifferent(source.str().c_str(),
                                           target.str().c_str())) {
-    cmCPackLogger(cmCPackLog::LOG_ERROR, "Error copying "
-                    << source.str() << " to " << target.str() << std::endl);
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Error copying " << source.str() << " to " << target.str()
+                                   << std::endl);
 
     return false;
   }
@@ -248,8 +251,8 @@ bool cmCPackDragNDropGenerator::RunCommand(std::ostringstream& command,
     this->GeneratorVerbose, cmDuration::zero());
 
   if (!result || exit_code) {
-    cmCPackLogger(cmCPackLog::LOG_ERROR, "Error executing: " << command.str()
-                                                             << std::endl);
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Error executing: " << command.str() << std::endl);
 
     return false;
   }
@@ -400,8 +403,8 @@ int cmCPackDragNDropGenerator::CreateDMG(const std::string& src_dir,
     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);
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "Error creating dummy padding file." << std::endl);
 
       return 0;
     }
@@ -460,8 +463,8 @@ int cmCPackDragNDropGenerator::CreateDMG(const std::string& src_dir,
     std::ostringstream dummy_padding;
     dummy_padding << temp_mount << "/.dummy-padding-file";
     if (!cmSystemTools::RemoveFile(dummy_padding.str())) {
-      cmCPackLogger(cmCPackLog::LOG_ERROR, "Error removing dummy padding file."
-                      << std::endl);
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "Error removing dummy padding file." << std::endl);
 
       had_error = true;
     }
@@ -565,8 +568,9 @@ int cmCPackDragNDropGenerator::CreateDMG(const std::string& src_dir,
           CFLocaleCreateCanonicalLanguageIdentifierFromString(
             nullptr, language_cfstring);
         if (!iso_language) {
-          cmCPackLogger(cmCPackLog::LOG_ERROR, languages[i]
-                          << " is not a recognized language" << std::endl);
+          cmCPackLogger(cmCPackLog::LOG_ERROR,
+                        languages[i] << " is not a recognized language"
+                                     << std::endl);
         }
         char iso_language_cstr[65];
         CFStringGetCString(iso_language, iso_language_cstr,
@@ -638,9 +642,10 @@ int cmCPackDragNDropGenerator::CreateDMG(const std::string& src_dir,
     ofs.Close();
 
     if (have_write_license_error) {
-      cmCPackLogger(cmCPackLog::LOG_ERROR, "Error writing license file to SLA."
-                      << std::endl
-                      << error << std::endl);
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "Error writing license file to SLA." << std::endl
+                                                         << error
+                                                         << std::endl);
       return 0;
     }
 
@@ -692,9 +697,9 @@ int cmCPackDragNDropGenerator::CreateDMG(const std::string& src_dir,
     embed_sla_command << "\"" << temp_image << "\"";
 
     if (!this->RunCommand(embed_sla_command, &error)) {
-      cmCPackLogger(cmCPackLog::LOG_ERROR, "Error adding SLA." << std::endl
-                                                               << error
-                                                               << std::endl);
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "Error adding SLA." << std::endl
+                                        << error << std::endl);
       return 0;
     }
 
@@ -726,9 +731,10 @@ int cmCPackDragNDropGenerator::CreateDMG(const std::string& src_dir,
   std::string convert_error;
 
   if (!this->RunCommand(final_image_command, &convert_error)) {
-    cmCPackLogger(cmCPackLog::LOG_ERROR, "Error compressing disk image."
-                    << std::endl
-                    << convert_error << std::endl);
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Error compressing disk image." << std::endl
+                                                  << convert_error
+                                                  << std::endl);
 
     return 0;
   }
diff --git a/Source/CPack/cmCPackGenerator.cxx b/Source/CPack/cmCPackGenerator.cxx
index d838b301f..f15445b1a 100644
--- a/Source/CPack/cmCPackGenerator.cxx
+++ b/Source/CPack/cmCPackGenerator.cxx
@@ -6,6 +6,7 @@
 #include "cmsys/Glob.hxx"
 #include "cmsys/RegularExpression.hxx"
 #include <algorithm>
+#include <cstring>
 #include <memory> // IWYU pragma: keep
 #include <utility>
 
@@ -24,8 +25,8 @@
 #include "cmake.h"
 
 #if defined(__HAIKU__)
-#include <FindDirectory.h>
-#include <StorageDefs.h>
+#  include <FindDirectory.h>
+#  include <StorageDefs.h>
 #endif
 
 cmCPackGenerator::cmCPackGenerator()
@@ -60,9 +61,10 @@ int cmCPackGenerator::PrepareNames()
   // 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);
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "CPACK_SET_DESTDIR is set to ON but the '"
+                      << Name << "' generator does NOT support it."
+                      << std::endl);
       return 0;
     }
     if (SETDESTDIR_SHOULD_NOT_BE_USED == SupportsSetDestdir()) {
@@ -91,8 +93,8 @@ int cmCPackGenerator::PrepareNames()
   std::string outName = pfname;
   tempDirectory += "/" + outName;
   if (!this->GetOutputExtension()) {
-    cmCPackLogger(cmCPackLog::LOG_ERROR, "No output extension specified"
-                    << std::endl);
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "No output extension specified" << std::endl);
     return 0;
   }
   outName += this->GetOutputExtension();
@@ -124,8 +126,8 @@ int cmCPackGenerator::PrepareNames()
                 "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);
+    cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                  "Look for: " << descFileName << std::endl);
     if (!cmSystemTools::FileExists(descFileName)) {
       cmCPackLogger(cmCPackLog::LOG_ERROR,
                     "Cannot find description file name: ["
@@ -160,8 +162,9 @@ int cmCPackGenerator::PrepareNames()
   const char* algoSignature = this->GetOption("CPACK_PACKAGE_CHECKSUM");
   if (algoSignature) {
     if (!cmCryptoHash::New(algoSignature)) {
-      cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot recognize algorithm: "
-                      << algoSignature << std::endl);
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "Cannot recognize algorithm: " << algoSignature
+                                                   << std::endl);
       return 0;
     }
   }
@@ -214,7 +217,8 @@ int cmCPackGenerator::InstallProject()
     cmSystemTools::ExpandListArgument(default_dir_install_permissions, items);
     for (const auto& arg : items) {
       if (!cmFSPermissions::stringToModeT(arg, default_dir_mode_v)) {
-        cmCPackLogger(cmCPackLog::LOG_ERROR, "Invalid permission value '"
+        cmCPackLogger(cmCPackLog::LOG_ERROR,
+                      "Invalid permission value '"
                         << arg
                         << "'."
                            " CPACK_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS "
@@ -288,10 +292,11 @@ int cmCPackGenerator::InstallProjectViaInstallCommands(
         ofs << "# Run command: " << ic << std::endl
             << "# Output:" << std::endl
             << output << std::endl;
-        cmCPackLogger(
-          cmCPackLog::LOG_ERROR, "Problem running install command: "
-            << ic << std::endl
-            << "Please check " << tmpFile << " for errors" << std::endl);
+        cmCPackLogger(cmCPackLog::LOG_ERROR,
+                      "Problem running install command: "
+                        << ic << std::endl
+                        << "Please check " << tmpFile << " for errors"
+                        << std::endl);
         return 0;
       }
     }
@@ -375,8 +380,9 @@ int cmCPackGenerator::InstallProjectViaInstalledDirectories(
         }
         std::string filePath = tempDir;
         filePath += "/" + subdir + "/" + cmSystemTools::RelativePath(top, gf);
-        cmCPackLogger(cmCPackLog::LOG_DEBUG, "Copy file: "
-                        << inFile << " -> " << filePath << std::endl);
+        cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                      "Copy file: " << inFile << " -> " << filePath
+                                    << std::endl);
         /* If the file is a symlink we will have to re-create it */
         if (cmSystemTools::FileIsSymlink(inFile)) {
           std::string targetFile;
@@ -391,8 +397,9 @@ int cmCPackGenerator::InstallProjectViaInstalledDirectories(
                                                       filePath.c_str()) &&
                    cmSystemTools::CopyFileTime(inFile.c_str(),
                                                filePath.c_str()))) {
-          cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem copying file: "
-                          << inFile << " -> " << filePath << std::endl);
+          cmCPackLogger(cmCPackLog::LOG_ERROR,
+                        "Problem copying file: " << inFile << " -> "
+                                                 << filePath << std::endl);
           return 0;
         }
       }
@@ -401,33 +408,44 @@ int cmCPackGenerator::InstallProjectViaInstalledDirectories(
         std::string curDir = cmSystemTools::GetCurrentWorkingDirectory();
         std::string goToDir = tempDir;
         goToDir += "/" + subdir;
-        cmCPackLogger(cmCPackLog::LOG_DEBUG, "Change dir to: " << goToDir
-                                                               << std::endl);
+        cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                      "Change dir to: " << goToDir << std::endl);
         cmWorkingDirectory workdir(goToDir);
-        for (auto const& symlinked : symlinkedFiles) {
-          cmCPackLogger(cmCPackLog::LOG_DEBUG, "Will create a symlink: "
-                          << symlinked.second << "--> " << symlinked.first
+        if (workdir.Failed()) {
+          cmCPackLogger(cmCPackLog::LOG_ERROR,
+                        "Failed to change working directory to "
+                          << goToDir << " : "
+                          << std::strerror(workdir.GetLastResult())
                           << std::endl);
+          return 0;
+        }
+        for (auto const& symlinked : symlinkedFiles) {
+          cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                        "Will create a symlink: " << symlinked.second << "--> "
+                                                  << symlinked.first
+                                                  << std::endl);
           // make sure directory exists for symlink
           std::string destDir =
             cmSystemTools::GetFilenamePath(symlinked.second);
           if (!destDir.empty() &&
               !cmSystemTools::MakeDirectory(destDir, default_dir_mode)) {
-            cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot create dir: "
+            cmCPackLogger(cmCPackLog::LOG_ERROR,
+                          "Cannot create dir: "
                             << destDir << "\nTrying to create symlink: "
                             << symlinked.second << "--> " << symlinked.first
                             << std::endl);
           }
           if (!cmSystemTools::CreateSymlink(symlinked.first,
                                             symlinked.second)) {
-            cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot create symlink: "
+            cmCPackLogger(cmCPackLog::LOG_ERROR,
+                          "Cannot create symlink: "
                             << symlinked.second << "--> " << symlinked.first
                             << std::endl);
             return 0;
           }
         }
-        cmCPackLogger(cmCPackLog::LOG_DEBUG, "Going back to: " << curDir
-                                                               << std::endl);
+        cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                      "Going back to: " << curDir << std::endl);
       }
     }
   }
@@ -439,8 +457,8 @@ int cmCPackGenerator::InstallProjectViaInstallScript(
 {
   const char* cmakeScripts = this->GetOption("CPACK_INSTALL_SCRIPT");
   if (cmakeScripts && *cmakeScripts) {
-    cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- Install scripts: " << cmakeScripts
-                                                                << std::endl);
+    cmCPackLogger(cmCPackLog::LOG_OUTPUT,
+                  "- Install scripts: " << cmakeScripts << std::endl);
     std::vector<std::string> cmakeScriptsVector;
     cmSystemTools::ExpandListArgument(cmakeScripts, cmakeScriptsVector);
     for (std::string const& installScript : cmakeScriptsVector) {
@@ -595,8 +613,9 @@ int cmCPackGenerator::InstallProjectViaInstallCMakeProjects(
           preinstall, buildConfig, "", false);
         cmCPackLogger(cmCPackLog::LOG_DEBUG,
                       "- Install command: " << buildCommand << std::endl);
-        cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- Run preinstall target for: "
-                        << installProjectName << std::endl);
+        cmCPackLogger(cmCPackLog::LOG_OUTPUT,
+                      "- Run preinstall target for: " << installProjectName
+                                                      << std::endl);
         std::string output;
         int retVal = 1;
         bool resB = cmSystemTools::RunSingleCommand(
@@ -611,10 +630,11 @@ int cmCPackGenerator::InstallProjectViaInstallCMakeProjects(
               << "# 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);
+          cmCPackLogger(cmCPackLog::LOG_ERROR,
+                        "Problem running install command: "
+                          << buildCommand << std::endl
+                          << "Please check " << tmpFile << " for errors"
+                          << std::endl);
           return 0;
         }
       }
@@ -628,8 +648,9 @@ int cmCPackGenerator::InstallProjectViaInstallCMakeProjects(
         std::string tempInstallDirectory = baseTempInstallDirectory;
         installComponent = component;
         if (componentInstall) {
-          cmCPackLogger(cmCPackLog::LOG_OUTPUT, "-   Install component: "
-                          << installComponent << std::endl);
+          cmCPackLogger(cmCPackLog::LOG_OUTPUT,
+                        "-   Install component: " << installComponent
+                                                  << std::endl);
         }
 
         cmake cm(cmake::RoleScript);
@@ -725,8 +746,8 @@ int cmCPackGenerator::InstallProjectViaInstallCMakeProjects(
            */
           cmSystemTools::PutEnv(std::string("DESTDIR=") +
                                 tempInstallDirectory);
-          cmCPackLogger(cmCPackLog::LOG_DEBUG, "- Creating directory: '"
-                          << dir << "'" << std::endl);
+          cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                        "- Creating directory: '" << dir << "'" << std::endl);
 
           if (!cmsys::SystemTools::MakeDirectory(dir, default_dir_mode)) {
             cmCPackLogger(
@@ -832,7 +853,8 @@ int cmCPackGenerator::InstallProjectViaInstallCMakeProjects(
             localFileName =
               localFileName.substr(localFileName.find_first_not_of('/'));
             Components[installComponent].Files.push_back(localFileName);
-            cmCPackLogger(cmCPackLog::LOG_DEBUG, "Adding file <"
+            cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                          "Adding file <"
                             << localFileName << "> to component <"
                             << installComponent << ">" << std::endl);
           }
@@ -904,16 +926,16 @@ void cmCPackGenerator::SetOption(const std::string& op, const char* value)
     this->MakefileMap->RemoveDefinition(op);
     return;
   }
-  cmCPackLogger(cmCPackLog::LOG_DEBUG, this->GetNameOfClass()
-                  << "::SetOption(" << op << ", " << value << ")"
-                  << std::endl);
+  cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                this->GetNameOfClass() << "::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
@@ -931,8 +953,9 @@ int cmCPackGenerator::DoPackage()
     const char* toplevelDirectory =
       this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
     if (cmSystemTools::FileExists(toplevelDirectory)) {
-      cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Remove toplevel directory: "
-                      << toplevelDirectory << std::endl);
+      cmCPackLogger(cmCPackLog::LOG_VERBOSE,
+                    "Remove toplevel directory: " << toplevelDirectory
+                                                  << std::endl);
       if (!cmSystemTools::RepeatedRemoveDirectory(toplevelDirectory)) {
         cmCPackLogger(cmCPackLog::LOG_ERROR,
                       "Problem removing toplevel directory: "
@@ -941,8 +964,8 @@ int cmCPackGenerator::DoPackage()
       }
     }
   }
-  cmCPackLogger(cmCPackLog::LOG_DEBUG, "About to install project "
-                  << std::endl);
+  cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                "About to install project " << std::endl);
 
   if (!this->InstallProject()) {
     return 0;
@@ -967,12 +990,13 @@ int cmCPackGenerator::DoPackage()
   }
 
   cmCPackLogger(cmCPackLog::LOG_OUTPUT, "Create package" << std::endl);
-  cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Package files to: "
+  cmCPackLogger(cmCPackLog::LOG_VERBOSE,
+                "Package files to: "
                   << (tempPackageFileName ? tempPackageFileName : "(NULL)")
                   << std::endl);
   if (cmSystemTools::FileExists(tempPackageFileName)) {
-    cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Remove old package file"
-                    << std::endl);
+    cmCPackLogger(cmCPackLog::LOG_VERBOSE,
+                  "Remove old package file" << std::endl);
     cmSystemTools::RemoveFile(tempPackageFileName);
   }
   if (cmSystemTools::IsOn(
@@ -994,11 +1018,12 @@ int cmCPackGenerator::DoPackage()
   { // scope that enables package generators to run internal scripts with
     // latest CMake policies enabled
     cmMakefile::ScopePushPop pp{ this->MakefileMap };
-    this->MakefileMap->SetPolicyVersion(cmVersion::GetCMakeVersion());
+    this->MakefileMap->SetPolicyVersion(cmVersion::GetCMakeVersion(),
+                                        std::string());
 
     if (!this->PackageFiles() || cmSystemTools::GetErrorOccuredFlag()) {
-      cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem compressing the directory"
-                      << std::endl);
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "Problem compressing the directory" << std::endl);
       return 0;
     }
   }
@@ -1013,8 +1038,9 @@ int cmCPackGenerator::DoPackage()
    *  - the initially provided name may have changed
    *    (because the specific generator did 'normalize' it)
    */
-  cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Copying final package(s) ["
-                  << packageFileNames.size() << "]:" << std::endl);
+  cmCPackLogger(cmCPackLog::LOG_VERBOSE,
+                "Copying final package(s) [" << packageFileNames.size()
+                                             << "]:" << std::endl);
   /* now copy package one by one */
   for (std::string const& pkgFileName : packageFileNames) {
     std::string tmpPF(this->GetOption("CPACK_OUTPUT_FILE_PREFIX"));
@@ -1022,20 +1048,23 @@ int cmCPackGenerator::DoPackage()
     tempPackageFileName = pkgFileName.c_str();
     tmpPF += "/" + filename;
     const char* packageFileName = tmpPF.c_str();
-    cmCPackLogger(cmCPackLog::LOG_DEBUG, "Copy final package(s): "
+    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: "
+        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);
 
     /* Generate checksum file */
     if (crypto) {
@@ -1044,13 +1073,15 @@ int cmCPackGenerator::DoPackage()
       hashFile += "." + cmSystemTools::LowerCase(algo);
       cmsys::ofstream outF(hashFile.c_str());
       if (!outF) {
-        cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot create checksum file: "
-                        << hashFile << std::endl);
+        cmCPackLogger(cmCPackLog::LOG_ERROR,
+                      "Cannot create checksum file: " << hashFile
+                                                      << std::endl);
         return 0;
       }
       outF << crypto->HashFile(packageFileName) << "  " << filename << "\n";
-      cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- checksum file: "
-                      << hashFile << " generated." << std::endl);
+      cmCPackLogger(cmCPackLog::LOG_OUTPUT,
+                    "- checksum file: " << hashFile << " generated."
+                                        << std::endl);
     }
   }
 
@@ -1170,7 +1201,8 @@ const char* cmCPackGenerator::GetInstallPath()
 
 const char* cmCPackGenerator::GetPackagingInstallPrefix()
 {
-  cmCPackLogger(cmCPackLog::LOG_DEBUG, "GetPackagingInstallPrefix: '"
+  cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                "GetPackagingInstallPrefix: '"
                   << this->GetOption("CPACK_PACKAGING_INSTALL_PREFIX") << "'"
                   << std::endl);
 
@@ -1179,11 +1211,12 @@ const char* cmCPackGenerator::GetPackagingInstallPrefix()
 
 std::string cmCPackGenerator::FindTemplate(const char* name)
 {
-  cmCPackLogger(cmCPackLog::LOG_DEBUG, "Look for template: "
-                  << (name ? name : "(NULL)") << std::endl);
+  cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                "Look for template: " << (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;
 }
 
@@ -1251,10 +1284,10 @@ int cmCPackGenerator::PrepareGroupingKind()
   }
 
   if (!groupingType.empty()) {
-    cmCPackLogger(cmCPackLog::LOG_VERBOSE, "["
-                    << this->Name << "]"
-                    << " requested component grouping = " << groupingType
-                    << std::endl);
+    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") {
@@ -1263,11 +1296,11 @@ int cmCPackGenerator::PrepareGroupingKind()
       method = ONE_PACKAGE_PER_GROUP;
     } else {
       cmCPackLogger(
-        cmCPackLog::LOG_WARNING, "["
-          << this->Name << "]"
-          << " requested component grouping type <" << groupingType
-          << "> UNKNOWN not in (ALL_COMPONENTS_IN_ONE,IGNORE,ONE_PER_GROUP)"
-          << std::endl);
+        cmCPackLog::LOG_WARNING,
+        "[" << this->Name << "]"
+            << " requested component grouping type <" << groupingType
+            << "> UNKNOWN not in (ALL_COMPONENTS_IN_ONE,IGNORE,ONE_PER_GROUP)"
+            << std::endl);
     }
   }
 
@@ -1281,11 +1314,11 @@ int cmCPackGenerator::PrepareGroupingKind()
       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);
+      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
@@ -1296,10 +1329,10 @@ int cmCPackGenerator::PrepareGroupingKind()
   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;
 }
@@ -1362,7 +1395,8 @@ bool cmCPackGenerator::SupportsComponentInstallation() const
 
 bool cmCPackGenerator::WantsComponentInstallation() const
 {
-  return (!IsOn("CPACK_MONOLITHIC_INSTALL") && SupportsComponentInstallation()
+  return (!IsOn("CPACK_MONOLITHIC_INSTALL") &&
+          SupportsComponentInstallation()
           // check that we have at least one group or component
           && (!this->ComponentGroups.empty() || !this->Components.empty()));
 }
diff --git a/Source/CPack/cmCPackGeneratorFactory.cxx b/Source/CPack/cmCPackGeneratorFactory.cxx
index 47e752707..d47e5ed28 100644
--- a/Source/CPack/cmCPackGeneratorFactory.cxx
+++ b/Source/CPack/cmCPackGeneratorFactory.cxx
@@ -9,12 +9,13 @@
 #include "cmAlgorithms.h"
 #include "cmCPack7zGenerator.h"
 #ifdef HAVE_FREEBSD_PKG
-#include "cmCPackFreeBSDGenerator.h"
+#  include "cmCPackFreeBSDGenerator.h"
 #endif
 #include "cmCPackDebGenerator.h"
 #include "cmCPackGenerator.h"
 #include "cmCPackLog.h"
 #include "cmCPackNSISGenerator.h"
+#include "cmCPackNuGetGenerator.h"
 #include "cmCPackSTGZGenerator.h"
 #include "cmCPackTGZGenerator.h"
 #include "cmCPackTXZGenerator.h"
@@ -23,25 +24,25 @@
 #include "cmCPackZIPGenerator.h"
 
 #ifdef __APPLE__
-#include "cmCPackBundleGenerator.h"
-#include "cmCPackDragNDropGenerator.h"
-#include "cmCPackOSXX11Generator.h"
-#include "cmCPackPackageMakerGenerator.h"
-#include "cmCPackProductBuildGenerator.h"
+#  include "cmCPackBundleGenerator.h"
+#  include "cmCPackDragNDropGenerator.h"
+#  include "cmCPackOSXX11Generator.h"
+#  include "cmCPackPackageMakerGenerator.h"
+#  include "cmCPackProductBuildGenerator.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 "cmCPackRPMGenerator.h"
+#  include "cmCPackRPMGenerator.h"
 #endif
 
 #if defined(_WIN32) || (defined(__CYGWIN__) && defined(HAVE_LIBUUID))
-#include "WiX/cmCPackWIXGenerator.h"
+#  include "WiX/cmCPackWIXGenerator.h"
 #endif
 
 cmCPackGeneratorFactory::cmCPackGeneratorFactory()
@@ -105,6 +106,10 @@ cmCPackGeneratorFactory::cmCPackGeneratorFactory()
     this->RegisterGenerator("DEB", "Debian packages",
                             cmCPackDebGenerator::CreateGenerator);
   }
+  if (cmCPackNuGetGenerator::CanGenerate()) {
+    this->RegisterGenerator("NuGet", "NuGet packages",
+                            cmCPackNuGetGenerator::CreateGenerator);
+  }
 #ifdef __APPLE__
   if (cmCPackDragNDropGenerator::CanGenerate()) {
     this->RegisterGenerator("DragNDrop", "Mac OSX Drag And Drop",
diff --git a/Source/CPack/cmCPackLog.h b/Source/CPack/cmCPackLog.h
index 10deda450..8e9922121 100644
--- a/Source/CPack/cmCPackLog.h
+++ b/Source/CPack/cmCPackLog.h
@@ -84,7 +84,7 @@ public:
   bool SetLogOutputFile(const char* fname);
 
   //! Set the various prefixes for the logging. SetPrefix sets the generic
-  // prefix that overwrittes missing ones.
+  // prefix that overwrites missing ones.
   void SetPrefix(std::string const& pfx) { this->Prefix = pfx; }
   void SetOutputPrefix(std::string const& pfx) { this->OutputPrefix = pfx; }
   void SetVerbosePrefix(std::string const& pfx) { this->VerbosePrefix = pfx; }
diff --git a/Source/CPack/cmCPackNSISGenerator.cxx b/Source/CPack/cmCPackNSISGenerator.cxx
index 3f7164a5d..a893a0f72 100644
--- a/Source/CPack/cmCPackNSISGenerator.cxx
+++ b/Source/CPack/cmCPackNSISGenerator.cxx
@@ -20,9 +20,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)
@@ -81,8 +81,8 @@ int cmCPackNSISGenerator::PackageFiles()
 
     str << "  Delete \"" << outputDir << "\\" << 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);
@@ -117,12 +117,13 @@ int cmCPackNSISGenerator::PackageFiles()
       this->Components[componentName].Directories.push_back(std::move(fileN));
     }
   }
-  cmCPackLogger(cmCPackLog::LOG_DEBUG, "Uninstall Dirs: " << dstr.str()
-                                                          << std::endl);
+  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);
+  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;
@@ -308,10 +309,11 @@ int cmCPackNSISGenerator::PackageFiles()
     ofs << "# Run command: " << nsisCmd << 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);
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Problem running NSIS command: " << nsisCmd << std::endl
+                                                   << "Please check "
+                                                   << tmpFile << " for errors"
+                                                   << std::endl);
     return 0;
   }
   return 1;
@@ -329,28 +331,31 @@ int cmCPackNSISGenerator::InitializeInternal()
     this->SetOption("CPACK_INCLUDE_TOPLEVEL_DIRECTORY", nullptr);
   }
 
-  cmCPackLogger(cmCPackLog::LOG_DEBUG, "cmCPackNSISGenerator::Initialize()"
-                  << std::endl);
+  cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                "cmCPackNSISGenerator::Initialize()" << 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 (!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 &&
@@ -358,13 +363,15 @@ int cmCPackNSISGenerator::InitializeInternal()
         "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;
   }
 
@@ -395,8 +402,8 @@ int cmCPackNSISGenerator::InitializeInternal()
   }
 
   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(
@@ -413,17 +420,18 @@ int cmCPackNSISGenerator::InitializeInternal()
     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);
+    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)) {
     double nsisVersion = atof(versionRex.match(1).c_str());
     double minNSISVersion = 2.09;
-    cmCPackLogger(cmCPackLog::LOG_DEBUG, "NSIS Version: " << nsisVersion
-                                                          << std::endl);
+    cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                  "NSIS Version: " << nsisVersion << std::endl);
     if (nsisVersion < minNSISVersion) {
       cmCPackLogger(cmCPackLog::LOG_ERROR,
                     "CPack requires NSIS Version 2.09 or greater.  "
@@ -434,8 +442,8 @@ int cmCPackNSISGenerator::InitializeInternal()
   }
   if (versionRexCVS.find(output)) {
     // No version check for NSIS cvs build
-    cmCPackLogger(cmCPackLog::LOG_DEBUG, "NSIS Version: CVS "
-                    << versionRexCVS.match(1) << std::endl);
+    cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                  "NSIS Version: CVS " << versionRexCVS.match(1) << std::endl);
   }
   this->SetOptionIfNotSet("CPACK_INSTALLER_PROGRAM", nsisPath.c_str());
   this->SetOptionIfNotSet("CPACK_NSIS_EXECUTABLES_DIRECTORY", "bin");
@@ -447,8 +455,9 @@ int cmCPackNSISGenerator::InitializeInternal()
     this->GetOption("CPACK_NSIS_EXECUTABLES_DIRECTORY");
   std::vector<std::string> cpackPackageDesktopLinksVector;
   if (cpackPackageDeskTopLinks) {
-    cmCPackLogger(cmCPackLog::LOG_DEBUG, "CPACK_CREATE_DESKTOP_LINKS: "
-                    << cpackPackageDeskTopLinks << std::endl);
+    cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                  "CPACK_CREATE_DESKTOP_LINKS: " << cpackPackageDeskTopLinks
+                                                 << std::endl);
 
     cmSystemTools::ExpandListArgument(cpackPackageDeskTopLinks,
                                       cpackPackageDesktopLinksVector);
@@ -457,7 +466,8 @@ int cmCPackNSISGenerator::InitializeInternal()
                     "CPACK_CREATE_DESKTOP_LINKS: " << cpdl << std::endl);
     }
   } else {
-    cmCPackLogger(cmCPackLog::LOG_DEBUG, "CPACK_CREATE_DESKTOP_LINKS: "
+    cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                  "CPACK_CREATE_DESKTOP_LINKS: "
                     << "not set" << std::endl);
   }
 
@@ -465,8 +475,9 @@ int cmCPackNSISGenerator::InitializeInternal()
   std::ostringstream deleteStr;
 
   if (cpackPackageExecutables) {
-    cmCPackLogger(cmCPackLog::LOG_DEBUG, "The cpackPackageExecutables: "
-                    << cpackPackageExecutables << "." << std::endl);
+    cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                  "The cpackPackageExecutables: " << cpackPackageExecutables
+                                                  << "." << std::endl);
     std::vector<std::string> cpackPackageExecutablesVector;
     cmSystemTools::ExpandListArgument(cpackPackageExecutables,
                                       cpackPackageExecutablesVector);
@@ -683,8 +694,9 @@ std::string cmCPackNSISGenerator::CreateComponentDescription(
                                                                 << std::endl);
     if (cmSystemTools::FileExists(archiveFile, true)) {
       if (!cmSystemTools::RemoveFile(archiveFile)) {
-        cmCPackLogger(cmCPackLog::LOG_ERROR, "Unable to remove archive file "
-                        << archiveFile << std::endl);
+        cmCPackLogger(cmCPackLog::LOG_ERROR,
+                      "Unable to remove archive file " << archiveFile
+                                                       << std::endl);
         return "";
       }
     }
@@ -694,8 +706,8 @@ std::string cmCPackNSISGenerator::CreateComponentDescription(
       this->ReadListFile("CPackZIP.cmake");
 
       if (!this->IsSet("ZIP_EXECUTABLE")) {
-        cmCPackLogger(cmCPackLog::LOG_ERROR, "Unable to find ZIP program"
-                        << std::endl);
+        cmCPackLogger(cmCPackLog::LOG_ERROR,
+                      "Unable to find ZIP program" << std::endl);
         return "";
       }
     }
@@ -746,10 +758,11 @@ std::string cmCPackNSISGenerator::CreateComponentDescription(
       ofs << "# Run command: " << cmd << 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);
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "Problem running zip command: " << cmd << std::endl
+                                                    << "Please check "
+                                                    << tmpFile << " for errors"
+                                                    << std::endl);
       return "";
     }
 
diff --git a/Source/CPack/cmCPackNuGetGenerator.cxx b/Source/CPack/cmCPackNuGetGenerator.cxx
new file mode 100644
index 000000000..2ae8cbac8
--- /dev/null
+++ b/Source/CPack/cmCPackNuGetGenerator.cxx
@@ -0,0 +1,141 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCPackNuGetGenerator.h"
+
+#include "cmAlgorithms.h"
+#include "cmCPackComponentGroup.h"
+#include "cmCPackLog.h"
+#include "cmSystemTools.h"
+
+#include <algorithm>
+#include <iterator>
+#include <map>
+#include <ostream>
+#include <string>
+#include <utility>
+#include <vector>
+
+bool cmCPackNuGetGenerator::SupportsComponentInstallation() const
+{
+  return IsOn("CPACK_NUGET_COMPONENT_INSTALL");
+}
+
+int cmCPackNuGetGenerator::PackageFiles()
+{
+  cmCPackLogger(cmCPackLog::LOG_DEBUG, "Toplevel: " << toplevel << std::endl);
+
+  /* Reset package file name list it will be populated after the
+   * `CPackNuGet.cmake` run */
+  packageFileNames.clear();
+
+  /* Are we in the component packaging case */
+  if (WantsComponentInstallation()) {
+    if (componentPackageMethod == ONE_PACKAGE) {
+      // CASE 1 : COMPONENT ALL-IN-ONE package
+      // Meaning that all per-component pre-installed files
+      // goes into the single package.
+      this->SetOption("CPACK_NUGET_ALL_IN_ONE", "TRUE");
+      SetupGroupComponentVariables(true);
+    } else {
+      // 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.
+      SetupGroupComponentVariables(componentPackageMethod ==
+                                   ONE_PACKAGE_PER_COMPONENT);
+    }
+  } else {
+    // CASE 3 : NON COMPONENT package.
+    this->SetOption("CPACK_NUGET_ORDINAL_MONOLITIC", "TRUE");
+  }
+
+  auto retval = this->ReadListFile("CPackNuGet.cmake");
+  if (retval) {
+    AddGeneratedPackageNames();
+  } else {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Error while execution CPackNuGet.cmake" << std::endl);
+  }
+
+  return retval;
+}
+
+void cmCPackNuGetGenerator::SetupGroupComponentVariables(bool ignoreGroup)
+{
+  // The default behavior is to have one package by component group
+  // unless CPACK_COMPONENTS_IGNORE_GROUP is specified.
+  if (!ignoreGroup) {
+    std::vector<std::string> groups;
+    for (auto const& compG : this->ComponentGroups) {
+      cmCPackLogger(cmCPackLog::LOG_VERBOSE,
+                    "Packaging component group: " << compG.first << std::endl);
+      groups.push_back(compG.first);
+      auto compGUp =
+        cmSystemTools::UpperCase(cmSystemTools::MakeCidentifier(compG.first));
+
+      // Collect components for this group
+      std::vector<std::string> components;
+      std::transform(begin(compG.second.Components),
+                     end(compG.second.Components),
+                     std::back_inserter(components),
+                     [](cmCPackComponent const* comp) { return comp->Name; });
+      this->SetOption("CPACK_NUGET_" + compGUp + "_GROUP_COMPONENTS",
+                      cmJoin(components, ";").c_str());
+    }
+    if (!groups.empty()) {
+      this->SetOption("CPACK_NUGET_GROUPS", cmJoin(groups, ";").c_str());
+    }
+
+    // Handle Orphan components (components not belonging to any groups)
+    std::vector<std::string> components;
+    for (auto const& comp : this->Components) {
+      // Does the component belong to a group?
+      if (comp.second.Group == nullptr) {
+        cmCPackLogger(
+          cmCPackLog::LOG_VERBOSE,
+          "Component <"
+            << comp.second.Name
+            << "> does not belong to any group, package it separately."
+            << std::endl);
+        components.push_back(comp.first);
+      }
+    }
+    if (!components.empty()) {
+      this->SetOption("CPACK_NUGET_COMPONENTS",
+                      cmJoin(components, ";").c_str());
+    }
+
+  } else {
+    std::vector<std::string> components;
+    components.reserve(this->Components.size());
+    std::transform(begin(this->Components), end(this->Components),
+                   std::back_inserter(components),
+                   [](std::pair<std::string, cmCPackComponent> const& comp) {
+                     return comp.first;
+                   });
+    this->SetOption("CPACK_NUGET_COMPONENTS", cmJoin(components, ";").c_str());
+  }
+}
+
+void cmCPackNuGetGenerator::AddGeneratedPackageNames()
+{
+  const char* const files_list = this->GetOption("GEN_CPACK_OUTPUT_FILES");
+  if (!files_list) {
+    cmCPackLogger(
+      cmCPackLog::LOG_ERROR,
+      "Error while execution CPackNuGet.cmake: No NuGet package has generated"
+        << std::endl);
+    return;
+  }
+  // add the generated packages to package file names list
+  std::string fileNames{ files_list };
+  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));
+}
diff --git a/Source/CPack/cmCPackNuGetGenerator.h b/Source/CPack/cmCPackNuGetGenerator.h
new file mode 100644
index 000000000..a59db2d04
--- /dev/null
+++ b/Source/CPack/cmCPackNuGetGenerator.h
@@ -0,0 +1,37 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCPackNuGetGenerator_h
+#define cmCPackNuGetGenerator_h
+
+#include "cmCPackGenerator.h"
+
+/** \class cmCPackNuGetGenerator
+ * \brief A generator for RPM packages
+ */
+class cmCPackNuGetGenerator : public cmCPackGenerator
+{
+public:
+  cmCPackTypeMacro(cmCPackNuGetGenerator, cmCPackGenerator);
+
+  // NOTE In fact, it is possible to have NuGet not only for Windows...
+  // https://docs.microsoft.com/en-us/nuget/install-nuget-client-tools
+  static bool CanGenerate() { return true; }
+
+protected:
+  bool SupportsComponentInstallation() const override;
+  int PackageFiles() override;
+
+  const char* GetOutputExtension() override { return ".nupkg"; }
+  bool SupportsAbsoluteDestination() const override { return false; }
+  /**
+   * The method used to prepare variables when component
+   * install is used.
+   */
+  void SetupGroupComponentVariables(bool ignoreGroup);
+  /**
+   * Populate \c packageFileNames vector of built packages.
+   */
+  void AddGeneratedPackageNames();
+};
+
+#endif
diff --git a/Source/CPack/cmCPackOSXX11Generator.cxx b/Source/CPack/cmCPackOSXX11Generator.cxx
index e750de3ea..dab72832c 100644
--- a/Source/CPack/cmCPackOSXX11Generator.cxx
+++ b/Source/CPack/cmCPackOSXX11Generator.cxx
@@ -27,8 +27,9 @@ int cmCPackOSXX11Generator::PackageFiles()
   const char* cpackPackageExecutables =
     this->GetOption("CPACK_PACKAGE_EXECUTABLES");
   if (cpackPackageExecutables) {
-    cmCPackLogger(cmCPackLog::LOG_DEBUG, "The cpackPackageExecutables: "
-                    << cpackPackageExecutables << "." << std::endl);
+    cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                  "The cpackPackageExecutables: " << cpackPackageExecutables
+                                                  << "." << std::endl);
     std::ostringstream str;
     std::ostringstream deleteStr;
     std::vector<std::string> cpackPackageExecutablesVector;
@@ -78,7 +79,8 @@ int cmCPackOSXX11Generator::PackageFiles()
   if (iconFile) {
     std::string iconFileName = cmsys::SystemTools::GetFilenameName(iconFile);
     if (!cmSystemTools::FileExists(iconFile)) {
-      cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot find icon file: "
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "Cannot find icon file: "
                       << iconFile
                       << ". Please check CPACK_PACKAGE_ICON setting."
                       << std::endl);
@@ -109,8 +111,8 @@ int cmCPackOSXX11Generator::PackageFiles()
       !this->CopyResourcePlistFile("OSXScriptLauncher", appdir,
                                    this->GetOption("CPACK_PACKAGE_FILE_NAME"),
                                    true)) {
-    cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem copying the resource files"
-                    << std::endl);
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Problem copying the resource files" << std::endl);
     return 0;
   }
 
@@ -147,8 +149,9 @@ int cmCPackOSXX11Generator::PackageFiles()
   dmgCmd << "\"" << this->GetOption("CPACK_INSTALLER_PROGRAM_DISK_IMAGE")
          << "\" create -ov -fs HFS+ -format UDZO -srcfolder \""
          << diskImageDirectory << "\" \"" << packageFileNames[0] << "\"";
-  cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Compress disk image using command: "
-                  << dmgCmd.str() << std::endl);
+  cmCPackLogger(cmCPackLog::LOG_VERBOSE,
+                "Compress disk image using command: " << dmgCmd.str()
+                                                      << std::endl);
   // since we get random dashboard failures with this one
   // try running it more than once
   int retVal = 1;
@@ -170,7 +173,8 @@ int cmCPackOSXX11Generator::PackageFiles()
     ofs << "# Run command: " << dmgCmd.str() << std::endl
         << "# Output:" << std::endl
         << output << std::endl;
-    cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem running hdiutil command: "
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Problem running hdiutil command: "
                     << dmgCmd.str() << std::endl
                     << "Please check " << tmpFile << " for errors"
                     << std::endl);
@@ -182,13 +186,13 @@ int cmCPackOSXX11Generator::PackageFiles()
 
 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()) {
-    cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot find hdiutil compiler"
-                    << std::endl);
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Cannot find hdiutil compiler" << std::endl);
     return 0;
   }
   this->SetOptionIfNotSet("CPACK_INSTALLER_PROGRAM_DISK_IMAGE",
@@ -263,8 +267,9 @@ bool cmCPackOSXX11Generator::CopyResourcePlistFile(
   destFileName += "/";
   destFileName += outputFileName;
 
-  cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Configure file: "
-                  << inFileName << " to " << destFileName << std::endl);
+  cmCPackLogger(cmCPackLog::LOG_VERBOSE,
+                "Configure file: " << inFileName << " to " << destFileName
+                                   << std::endl);
   this->ConfigureFile(inFileName.c_str(), destFileName.c_str(), copyOnly);
   return true;
 }
diff --git a/Source/CPack/cmCPackPKGGenerator.cxx b/Source/CPack/cmCPackPKGGenerator.cxx
index 9ea85405c..bdda38660 100644
--- a/Source/CPack/cmCPackPKGGenerator.cxx
+++ b/Source/CPack/cmCPackPKGGenerator.cxx
@@ -26,8 +26,8 @@ bool cmCPackPKGGenerator::SupportsComponentInstallation() const
 
 int cmCPackPKGGenerator::InitializeInternal()
 {
-  cmCPackLogger(cmCPackLog::LOG_DEBUG, "cmCPackPKGGenerator::Initialize()"
-                  << std::endl);
+  cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                "cmCPackPKGGenerator::Initialize()" << std::endl);
 
   return this->Superclass::InitializeInternal();
 }
@@ -52,8 +52,9 @@ void cmCPackPKGGenerator::WriteDistributionFile(const char* metapackageFile)
   std::string distributionTemplate =
     this->FindTemplate("CPack.distribution.dist.in");
   if (distributionTemplate.empty()) {
-    cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot find input file: "
-                    << distributionTemplate << std::endl);
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Cannot find input file: " << distributionTemplate
+                                             << std::endl);
     return;
   }
 
@@ -270,23 +271,26 @@ bool cmCPackPKGGenerator::CopyCreateResourceFile(const std::string& name,
   std::string cpackVar = "CPACK_RESOURCE_FILE_" + uname;
   const char* inFileName = this->GetOption(cpackVar);
   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);
+    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)) {
-    cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot find "
-                    << (!name.empty() ? name : "<empty>")
-                    << " resource file: " << inFileName << std::endl);
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Cannot find " << (!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: "
+      cmCPackLog::LOG_ERROR,
+      "Bad file extension specified: "
         << ext
         << ". Currently only .rtfd, .rtf, .html, and .txt files allowed."
         << std::endl);
@@ -330,8 +334,9 @@ bool cmCPackPKGGenerator::CopyResourcePlistFile(const std::string& name,
   destFileName += "/";
   destFileName += outName;
 
-  cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Configure file: "
-                  << inFileName << " to " << destFileName << std::endl);
+  cmCPackLogger(cmCPackLog::LOG_VERBOSE,
+                "Configure file: " << inFileName << " to " << destFileName
+                                   << std::endl);
   this->ConfigureFile(inFileName.c_str(), destFileName.c_str());
   return true;
 }
diff --git a/Source/CPack/cmCPackPackageMakerGenerator.cxx b/Source/CPack/cmCPackPackageMakerGenerator.cxx
index c515b857f..5b1a641a0 100644
--- a/Source/CPack/cmCPackPackageMakerGenerator.cxx
+++ b/Source/CPack/cmCPackPackageMakerGenerator.cxx
@@ -251,8 +251,8 @@ int cmCPackPackageMakerGenerator::PackageFiles()
       !this->CopyCreateResourceFile("Welcome", resDir) ||
       !this->CopyResourcePlistFile("Info.plist") ||
       !this->CopyResourcePlistFile("Description.plist")) {
-    cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem copying the resource files"
-                    << std::endl);
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Problem copying the resource files" << std::endl);
     return 0;
   }
 
@@ -311,7 +311,8 @@ int cmCPackPackageMakerGenerator::PackageFiles()
     ofs << "# Run command: " << dmgCmd.str() << std::endl
         << "# Output:" << std::endl
         << output << std::endl;
-    cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem running hdiutil command: "
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Problem running hdiutil command: "
                     << dmgCmd.str() << std::endl
                     << "Please check " << tmpFile << " for errors"
                     << std::endl);
@@ -357,8 +358,8 @@ int cmCPackPackageMakerGenerator::InitializeInternal()
   } else {
     pkgPath = cmSystemTools::FindProgram("PackageMaker", paths, false);
     if (pkgPath.empty()) {
-      cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot find PackageMaker compiler"
-                      << std::endl);
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "Cannot find PackageMaker compiler" << std::endl);
       return 0;
     }
     this->SetOptionIfNotSet("CPACK_INSTALLER_PROGRAM", pkgPath.c_str());
@@ -415,12 +416,13 @@ int cmCPackPackageMakerGenerator::InitializeInternal()
   }
   this->PackageMakerVersion = atof(rexVersion.match(1).c_str());
   if (this->PackageMakerVersion < 1.0) {
-    cmCPackLogger(cmCPackLog::LOG_ERROR, "Require PackageMaker 1.0 or higher"
-                    << std::endl);
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Require PackageMaker 1.0 or higher" << std::endl);
     return 0;
   }
-  cmCPackLogger(cmCPackLog::LOG_DEBUG, "PackageMaker version is: "
-                  << this->PackageMakerVersion << std::endl);
+  cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                "PackageMaker version is: " << 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
@@ -448,8 +450,8 @@ int cmCPackPackageMakerGenerator::InitializeInternal()
   std::vector<std::string> no_paths;
   pkgPath = cmSystemTools::FindProgram("hdiutil", no_paths, false);
   if (pkgPath.empty()) {
-    cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot find hdiutil compiler"
-                    << std::endl);
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Cannot find hdiutil compiler" << std::endl);
     return 0;
   }
   this->SetOptionIfNotSet("CPACK_INSTALLER_PROGRAM_DISK_IMAGE",
@@ -470,17 +472,18 @@ bool cmCPackPackageMakerGenerator::RunPackageMaker(const char* command,
   bool res = cmSystemTools::RunSingleCommand(
     command, &output, &output, &retVal, nullptr, this->GeneratorVerbose,
     cmDuration::zero());
-  cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Done running package maker"
-                  << std::endl);
+  cmCPackLogger(cmCPackLog::LOG_VERBOSE,
+                "Done running package maker" << std::endl);
   if (!res || retVal) {
     cmGeneratedFileStream ofs(tmpFile.c_str());
     ofs << "# Run command: " << command << std::endl
         << "# Output:" << std::endl
         << output << std::endl;
-    cmCPackLogger(
-      cmCPackLog::LOG_ERROR, "Problem running PackageMaker command: "
-        << command << std::endl
-        << "Please check " << tmpFile << " for errors" << std::endl);
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Problem running PackageMaker command: "
+                    << command << std::endl
+                    << "Please check " << tmpFile << " for errors"
+                    << std::endl);
     return false;
   }
   // sometimes the command finishes but the directory is not yet
@@ -505,8 +508,9 @@ 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;
diff --git a/Source/CPack/cmCPackProductBuildGenerator.cxx b/Source/CPack/cmCPackProductBuildGenerator.cxx
index 57cf7ea11..4ca0fa82b 100644
--- a/Source/CPack/cmCPackProductBuildGenerator.cxx
+++ b/Source/CPack/cmCPackProductBuildGenerator.cxx
@@ -67,8 +67,8 @@ int cmCPackProductBuildGenerator::PackageFiles()
       this->GetOption("CPACK_PRODUCTBUILD_RESOURCES_DIR");
 
     if (!cmSystemTools::CopyADirectory(userResDir, resDir)) {
-      cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem copying the resource files"
-                      << std::endl);
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "Problem copying the resource files" << std::endl);
       return 0;
     }
   }
@@ -121,16 +121,16 @@ int cmCPackProductBuildGenerator::InitializeInternal()
   std::string program =
     cmSystemTools::FindProgram("pkgbuild", no_paths, false);
   if (program.empty()) {
-    cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot find pkgbuild executable"
-                    << std::endl);
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Cannot find pkgbuild executable" << std::endl);
     return 0;
   }
   this->SetOptionIfNotSet("CPACK_COMMAND_PKGBUILD", program.c_str());
 
   program = cmSystemTools::FindProgram("productbuild", no_paths, false);
   if (program.empty()) {
-    cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot find productbuild executable"
-                    << std::endl);
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Cannot find productbuild executable" << std::endl);
     return 0;
   }
   this->SetOptionIfNotSet("CPACK_COMMAND_PRODUCTBUILD", program.c_str());
@@ -172,8 +172,9 @@ bool cmCPackProductBuildGenerator::GenerateComponentPackage(
   packageFile += '/';
   packageFile += packageFileName;
 
-  cmCPackLogger(cmCPackLog::LOG_OUTPUT, "-   Building component package: "
-                  << packageFile << std::endl);
+  cmCPackLogger(cmCPackLog::LOG_OUTPUT,
+                "-   Building component package: " << packageFile
+                                                   << std::endl);
 
   const char* comp_name = component ? component->Name.c_str() : nullptr;
 
diff --git a/Source/CPack/cmCPackRPMGenerator.cxx b/Source/CPack/cmCPackRPMGenerator.cxx
index e40b74d7e..c38988403 100644
--- a/Source/CPack/cmCPackRPMGenerator.cxx
+++ b/Source/CPack/cmCPackRPMGenerator.cxx
@@ -90,8 +90,8 @@ int cmCPackRPMGenerator::PackageOnePack(std::string const& initialToplevel,
   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);
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Error while execution CPackRPM.cmake" << std::endl);
     retval = 0;
   }
 
@@ -165,7 +165,8 @@ int cmCPackRPMGenerator::PackageComponents(bool ignoreGroup)
     }
 
     if (shouldSet) {
-      cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Setting "
+      cmCPackLogger(cmCPackLog::LOG_VERBOSE,
+                    "Setting "
                       << "CPACK_RPM_DEBUGINFO_PACKAGE because "
                       << "CPACK_RPM_DEBUGINFO_SINGLE_PACKAGE is set but "
                       << " none of the "
@@ -203,8 +204,9 @@ int cmCPackRPMGenerator::PackageComponents(bool ignoreGroup)
           continue;
         }
 
-        cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Packaging component group: "
-                        << compGIt->first << std::endl);
+        cmCPackLogger(cmCPackLog::LOG_VERBOSE,
+                      "Packaging component group: " << compGIt->first
+                                                    << std::endl);
         retval &= PackageOnePack(initialTopLevel, compGIt->first);
       }
       // Handle Orphan components (components not belonging to any groups)
@@ -226,7 +228,8 @@ int cmCPackRPMGenerator::PackageComponents(bool ignoreGroup)
           }
 
           cmCPackLogger(
-            cmCPackLog::LOG_VERBOSE, "Component <"
+            cmCPackLog::LOG_VERBOSE,
+            "Component <"
               << compIt->second.Name
               << "> does not belong to any group, package it separately."
               << std::endl);
@@ -242,7 +245,8 @@ int cmCPackRPMGenerator::PackageComponents(bool ignoreGroup)
         } else if (mainCompIt != this->Components.end()) {
           retval &= PackageOnePack(initialTopLevel, mainCompIt->first);
         } else {
-          cmCPackLogger(cmCPackLog::LOG_ERROR, "CPACK_RPM_MAIN_COMPONENT set"
+          cmCPackLogger(cmCPackLog::LOG_ERROR,
+                        "CPACK_RPM_MAIN_COMPONENT set"
                           << " to non existing component.\n");
           retval = 0;
         }
@@ -276,7 +280,8 @@ int cmCPackRPMGenerator::PackageComponents(bool ignoreGroup)
         if (mainCompIt != this->Components.end()) {
           retval &= PackageOnePack(initialTopLevel, mainCompIt->first);
         } else {
-          cmCPackLogger(cmCPackLog::LOG_ERROR, "CPACK_RPM_MAIN_COMPONENT set"
+          cmCPackLogger(cmCPackLog::LOG_ERROR,
+                        "CPACK_RPM_MAIN_COMPONENT set"
                           << " to non existing component.\n");
           retval = 0;
         }
@@ -290,8 +295,9 @@ int cmCPackRPMGenerator::PackageComponents(bool ignoreGroup)
       std::map<std::string, cmCPackComponentGroup>::iterator compGIt;
       for (compGIt = this->ComponentGroups.begin();
            compGIt != this->ComponentGroups.end(); ++compGIt) {
-        cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Packaging component group: "
-                        << compGIt->first << std::endl);
+        cmCPackLogger(cmCPackLog::LOG_VERBOSE,
+                      "Packaging component group: " << compGIt->first
+                                                    << std::endl);
         retval &= PackageOnePack(initialTopLevel, compGIt->first);
       }
       // Handle Orphan components (components not belonging to any groups)
@@ -301,7 +307,8 @@ int cmCPackRPMGenerator::PackageComponents(bool ignoreGroup)
         // Does the component belong to a group?
         if (compIt->second.Group == nullptr) {
           cmCPackLogger(
-            cmCPackLog::LOG_VERBOSE, "Component <"
+            cmCPackLog::LOG_VERBOSE,
+            "Component <"
               << compIt->second.Name
               << "> does not belong to any group, package it separately."
               << std::endl);
@@ -320,7 +327,8 @@ int cmCPackRPMGenerator::PackageComponents(bool ignoreGroup)
     }
   } else {
     cmCPackLogger(
-      cmCPackLog::LOG_ERROR, "CPACK_RPM_MAIN_COMPONENT not set but"
+      cmCPackLog::LOG_ERROR,
+      "CPACK_RPM_MAIN_COMPONENT not set but"
         << " it is mandatory with CPACK_RPM_DEBUGINFO_SINGLE_PACKAGE"
         << " being set.\n");
     retval = 0;
@@ -380,8 +388,8 @@ int cmCPackRPMGenerator::PackageComponentsAllInOne(
   if (this->ReadListFile("CPackRPM.cmake")) {
     AddGeneratedPackageNames();
   } else {
-    cmCPackLogger(cmCPackLog::LOG_ERROR, "Error while execution CPackRPM.cmake"
-                    << std::endl);
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Error while execution CPackRPM.cmake" << std::endl);
     retval = 0;
   }
 
diff --git a/Source/CPack/cmCPackSTGZGenerator.cxx b/Source/CPack/cmCPackSTGZGenerator.cxx
index 3d7fd3c14..ef0d1182c 100644
--- a/Source/CPack/cmCPackSTGZGenerator.cxx
+++ b/Source/CPack/cmCPackSTGZGenerator.cxx
@@ -56,7 +56,7 @@ int cmCPackSTGZGenerator::PackageFiles()
                                               S_IRGRP | S_IWGRP | S_IXGRP |
                                               S_IROTH | S_IWOTH | S_IXOTH
 #endif
-                                            );
+    );
   }
   return retval;
 }
@@ -100,8 +100,8 @@ int cmCPackSTGZGenerator::GenerateHeader(std::ostream* os)
     ++ptr;
   }
   counter++;
-  cmCPackLogger(cmCPackLog::LOG_DEBUG, "Number of lines: " << counter
-                                                           << std::endl);
+  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/cpack.cxx b/Source/CPack/cpack.cxx
index b6ff38b84..c08394530 100644
--- a/Source/CPack/cpack.cxx
+++ b/Source/CPack/cpack.cxx
@@ -13,7 +13,7 @@
 #include <vector>
 
 #if defined(_WIN32) && defined(CMAKE_BUILD_WITH_CMAKE)
-#include "cmsys/ConsoleBuf.hxx"
+#  include "cmsys/ConsoleBuf.hxx"
 #endif
 
 #include "cmCPackGenerator.h"
@@ -33,23 +33,25 @@ static const char* cmDocumentationName[][2] = {
 };
 
 static const char* cmDocumentationUsage[][2] = {
-  { nullptr, "  cpack -G <generator> [options]" },
+  // clang-format off
+  { nullptr, "  cpack [options]" },
   { nullptr, nullptr }
+  // clang-format on
 };
 
 static const char* cmDocumentationOptions[][2] = {
-  { "-G <generator>", "Use the specified generator to generate package." },
+  { "-G <generators>", "Override/define CPACK_GENERATOR" },
   { "-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" },
+  { "--config <configFile>", "Specify the config file." },
+  { "--verbose,-V", "Enable verbose output" },
   { "--trace", "Put underlying cmake scripts in trace mode." },
   { "--trace-expand", "Put underlying cmake scripts in expanded trace mode." },
-  { "--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" },
+  { "--debug", "Enable debug output (for CPack developers)" },
+  { "-P <packageName>", "Override/define CPACK_PACKAGE_NAME" },
+  { "-R <packageVersion>", "Override/define CPACK_PACKAGE_VERSION" },
+  { "-B <packageDirectory>", "Override/define CPACK_PACKAGE_DIRECTORY" },
+  { "--vendor <vendorName>", "Override/define CPACK_PACKAGE_VENDOR" },
   { nullptr, nullptr }
 };
 
@@ -80,8 +82,9 @@ int cpackDefinitionArgument(const char* argument, const char* cValue,
   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);
+  cmCPack_Log(def->Log, cmCPackLog::LOG_DEBUG,
+              "Set CPack variable: " << key << " to \"" << value << "\""
+                                     << std::endl);
   return 1;
 }
 
@@ -318,8 +321,8 @@ int main(int argc, char const* const* argv)
     }
     const char* genList = globalMF.GetDefinition("CPACK_GENERATOR");
     if (!genList) {
-      cmCPack_Log(&log, cmCPackLog::LOG_ERROR, "CPack generator not specified"
-                    << std::endl);
+      cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
+                  "CPack generator not specified" << std::endl);
     } else {
       std::vector<std::string> generatorsVector;
       cmSystemTools::ExpandListArgument(genList, generatorsVector);
@@ -382,8 +385,9 @@ int main(int argc, char const* const* argv)
           }
           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,
+                        "Use generator: " << cpackGenerator->GetNameOfClass()
+                                          << std::endl);
             cmCPack_Log(&log, cmCPackLog::LOG_VERBOSE,
                         "For project: " << projName << std::endl);
 
diff --git a/Source/CTest/cmCTestBZR.cxx b/Source/CTest/cmCTestBZR.cxx
index 015220091..365f26774 100644
--- a/Source/CTest/cmCTestBZR.cxx
+++ b/Source/CTest/cmCTestBZR.cxx
@@ -155,8 +155,9 @@ bool 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");
+  cmCTestLog(this->CTest, HANDLER_OUTPUT,
+             "   Old revision of repository is: " << this->OldRevision
+                                                  << "\n");
   this->PriorRev.Rev = this->OldRevision;
   return true;
 }
@@ -165,14 +166,16 @@ bool 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");
+  cmCTestLog(this->CTest, HANDLER_OUTPUT,
+             "   New revision of repository is: " << this->NewRevision
+                                                  << "\n");
   this->Log << "URL = " << this->URL << "\n";
   return true;
 }
 
-class cmCTestBZR::LogParser : public cmCTestVC::OutputLogger,
-                              private cmXMLParser
+class cmCTestBZR::LogParser
+  : public cmCTestVC::OutputLogger
+  , private cmXMLParser
 {
 public:
   LogParser(cmCTestBZR* bzr, const char* prefix)
diff --git a/Source/CTest/cmCTestBuildAndTestHandler.cxx b/Source/CTest/cmCTestBuildAndTestHandler.cxx
index 2e1ea4c3a..fccbc9530 100644
--- a/Source/CTest/cmCTestBuildAndTestHandler.cxx
+++ b/Source/CTest/cmCTestBuildAndTestHandler.cxx
@@ -11,6 +11,7 @@
 
 #include "cmsys/Process.h"
 #include <chrono>
+#include <cstring>
 #include <ratio>
 #include <stdlib.h>
 
@@ -196,6 +197,16 @@ int cmCTestBuildAndTestHandler::RunCMakeAndTest(std::string* outstring)
     cmSystemTools::MakeDirectory(this->BinaryDir);
   }
   cmWorkingDirectory workdir(this->BinaryDir);
+  if (workdir.Failed()) {
+    auto msg = "Failed to change working directory to " + this->BinaryDir +
+      " : " + std::strerror(workdir.GetLastResult()) + "\n";
+    if (outstring) {
+      *outstring = msg;
+    } else {
+      cmCTestLog(this->CTest, ERROR_MESSAGE, msg);
+    }
+    return 1;
+  }
 
   if (this->BuildNoCMake) {
     // Make the generator available for the Build call below.
@@ -242,9 +253,9 @@ int cmCTestBuildAndTestHandler::RunCMakeAndTest(std::string* outstring)
       config = "Debug";
     }
     int retVal = cm.GetGlobalGenerator()->Build(
-      this->SourceDir, this->BinaryDir, this->BuildProject, tar, output,
-      this->BuildMakeProgram, config, !this->BuildNoClean, false, false,
-      remainingTime);
+      cmake::NO_BUILD_PARALLEL_LEVEL, this->SourceDir, this->BinaryDir,
+      this->BuildProject, tar, output, this->BuildMakeProgram, config,
+      !this->BuildNoClean, false, false, remainingTime);
     out << output;
     // if the build failed then return
     if (retVal) {
@@ -307,7 +318,16 @@ int cmCTestBuildAndTestHandler::RunCMakeAndTest(std::string* outstring)
   // run the test from the this->BuildRunDir if set
   if (!this->BuildRunDir.empty()) {
     out << "Run test in directory: " << this->BuildRunDir << "\n";
-    cmSystemTools::ChangeDirectory(this->BuildRunDir);
+    if (!workdir.SetDirectory(this->BuildRunDir)) {
+      out << "Failed to change working directory : "
+          << std::strerror(workdir.GetLastResult()) << "\n";
+      if (outstring) {
+        *outstring = out.str();
+      } else {
+        cmCTestLog(this->CTest, ERROR_MESSAGE, out.str());
+      }
+      return 1;
+    }
   }
   out << "Running test command: \"" << fullPath << "\"";
   for (std::string const& testCommandArg : this->TestCommandArgs) {
diff --git a/Source/CTest/cmCTestBuildHandler.cxx b/Source/CTest/cmCTestBuildHandler.cxx
index ce6fbc75d..8527d5497 100644
--- a/Source/CTest/cmCTestBuildHandler.cxx
+++ b/Source/CTest/cmCTestBuildHandler.cxx
@@ -299,7 +299,8 @@ int cmCTestBuildHandler::ProcessHandler()
       this->ErrorWarningFileLineRegex.push_back(std::move(r));
     } else {
       cmCTestLog(
-        this->CTest, ERROR_MESSAGE, "Problem Compiling regular expression: "
+        this->CTest, ERROR_MESSAGE,
+        "Problem Compiling regular expression: "
           << cmCTestWarningErrorFileLine[entry].RegularExpressionString
           << std::endl);
     }
@@ -331,8 +332,8 @@ int cmCTestBuildHandler::ProcessHandler()
   cmGeneratedFileStream ofs;
   auto elapsed_time_start = std::chrono::steady_clock::now();
   if (!this->StartLogFile("Build", ofs)) {
-    cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot create build log file"
-                 << std::endl);
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Cannot create build log file" << std::endl);
   }
 
   // Create lists of regular expression strings for errors, error exceptions,
@@ -352,7 +353,7 @@ int cmCTestBuildHandler::ProcessHandler()
     this->CustomWarningExceptions.push_back(cmCTestWarningExceptions[cc]);
   }
 
-// Pre-compile regular expressions objects for all regular expressions
+  // Pre-compile regular expressions objects for all regular expressions
 
 #define cmCTestBuildHandlerPopulateRegexVector(strings, regexes)              \
   regexes.clear();                                                            \
@@ -452,8 +453,8 @@ int cmCTestBuildHandler::ProcessHandler()
   // Generate XML output
   cmGeneratedFileStream xofs;
   if (!this->StartResultingXML(cmCTest::PartBuild, "Build", xofs)) {
-    cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot create build XML file"
-                 << std::endl);
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Cannot create build XML file" << std::endl);
     return -1;
   }
   cmXMLWriter xml(xofs);
@@ -466,19 +467,20 @@ int cmCTestBuildHandler::ProcessHandler()
   this->GenerateXMLFooter(xml, elapsed_build_time);
 
   if (res != cmsysProcess_State_Exited || retVal || this->TotalErrors > 0) {
-    cmCTestLog(this->CTest, ERROR_MESSAGE, "Error(s) when building project"
-                 << std::endl);
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Error(s) when building project" << 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;
 }
@@ -779,8 +781,8 @@ int cmCTestBuildHandler::RunMakeCommand(const char* command, int* retVal,
   }
   argv.push_back(nullptr);
 
-  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Run command:",
-                     this->Quiet);
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     "Run command:", this->Quiet);
   for (char const* arg : argv) {
     if (!arg) {
       break;
@@ -812,7 +814,8 @@ int cmCTestBuildHandler::RunMakeCommand(const char* command, int* retVal,
   cmProcessOutput processOutput(encoding);
   std::string strdata;
   cmCTestOptionalLog(
-    this->CTest, HANDLER_PROGRESS_OUTPUT, "   Each symbol represents "
+    this->CTest, HANDLER_PROGRESS_OUTPUT,
+    "   Each symbol represents "
       << tick_len << " bytes of output." << std::endl
       << (this->UseCTestLaunch
             ? ""
@@ -868,7 +871,8 @@ int cmCTestBuildHandler::RunMakeCommand(const char* command, int* retVal,
                       &this->BuildProcessingQueue);
   this->ProcessBuffer(nullptr, 0, tick, tick_len, ofs,
                       &this->BuildProcessingErrorQueue);
-  cmCTestOptionalLog(this->CTest, HANDLER_PROGRESS_OUTPUT, " Size of output: "
+  cmCTestOptionalLog(this->CTest, HANDLER_PROGRESS_OUTPUT,
+                     " Size of output: "
                        << ((this->BuildOutputLogSize + 512) / 1024) << "K"
                        << std::endl,
                      this->Quiet);
@@ -921,8 +925,9 @@ int cmCTestBuildHandler::RunMakeCommand(const char* command, int* retVal,
     errorwarning.Error = true;
     this->ErrorsAndWarnings.push_back(std::move(errorwarning));
     this->TotalErrors++;
-    cmCTestLog(this->CTest, ERROR_MESSAGE, "There was an error: "
-                 << cmsysProcess_GetErrorString(cp) << std::endl);
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "There was an error: " << cmsysProcess_GetErrorString(cp)
+                                      << std::endl);
   }
 
   cmsysProcess_Delete(cp);
@@ -1049,7 +1054,8 @@ void cmCTestBuildHandler::ProcessBuffer(const char* data, size_t length,
                        this->LastTickChar, this->Quiet);
     tickDisplayed = true;
     if (tick % tick_line_len == 0 && tick > 0) {
-      cmCTestOptionalLog(this->CTest, HANDLER_PROGRESS_OUTPUT, "  Size: "
+      cmCTestOptionalLog(this->CTest, HANDLER_PROGRESS_OUTPUT,
+                         "  Size: "
                            << ((this->BuildOutputLogSize + 512) / 1024) << "K"
                            << std::endl
                            << "    ",
@@ -1103,7 +1109,8 @@ int cmCTestBuildHandler::ProcessSingleLine(const char* data)
     for (cmsys::RegularExpression& rx : this->ErrorExceptionRegex) {
       if (rx.find(data)) {
         errorLine = 0;
-        cmCTestOptionalLog(this->CTest, DEBUG, "  Not an error Line: "
+        cmCTestOptionalLog(this->CTest, DEBUG,
+                           "  Not an error Line: "
                              << data << " (matches: "
                              << this->CustomErrorExceptions[wrxCnt] << ")"
                              << std::endl,
@@ -1119,7 +1126,8 @@ int cmCTestBuildHandler::ProcessSingleLine(const char* data)
     for (cmsys::RegularExpression& rx : this->WarningMatchRegex) {
       if (rx.find(data)) {
         warningLine = 1;
-        cmCTestOptionalLog(this->CTest, DEBUG, "  Warning Line: "
+        cmCTestOptionalLog(this->CTest, DEBUG,
+                           "  Warning Line: "
                              << data << " (matches: "
                              << this->CustomWarningMatches[wrxCnt] << ")"
                              << std::endl,
@@ -1134,7 +1142,8 @@ int cmCTestBuildHandler::ProcessSingleLine(const char* data)
     for (cmsys::RegularExpression& rx : this->WarningExceptionRegex) {
       if (rx.find(data)) {
         warningLine = 0;
-        cmCTestOptionalLog(this->CTest, DEBUG, "  Not a warning Line: "
+        cmCTestOptionalLog(this->CTest, DEBUG,
+                           "  Not a warning Line: "
                              << data << " (matches: "
                              << this->CustomWarningExceptions[wrxCnt] << ")"
                              << std::endl,
diff --git a/Source/CTest/cmCTestCVS.cxx b/Source/CTest/cmCTestCVS.cxx
index 5779935aa..4fb3273bb 100644
--- a/Source/CTest/cmCTestCVS.cxx
+++ b/Source/CTest/cmCTestCVS.cxx
@@ -134,8 +134,9 @@ private:
 
   bool ProcessLine() override
   {
-    if (this->Line == ("======================================="
-                       "======================================")) {
+    if (this->Line ==
+        ("======================================="
+         "======================================")) {
       // This line ends the revision list.
       if (this->Section == SectionRevisions) {
         this->FinishRevision();
diff --git a/Source/CTest/cmCTestConfigureHandler.cxx b/Source/CTest/cmCTestConfigureHandler.cxx
index 821a94a00..5967b7458 100644
--- a/Source/CTest/cmCTestConfigureHandler.cxx
+++ b/Source/CTest/cmCTestConfigureHandler.cxx
@@ -51,8 +51,8 @@ int cmCTestConfigureHandler::ProcessHandler()
   if (!this->CTest->GetShowOnly()) {
     cmGeneratedFileStream os;
     if (!this->StartResultingXML(cmCTest::PartConfigure, "Configure", os)) {
-      cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot open configure file"
-                   << std::endl);
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "Cannot open configure file" << std::endl);
       return 1;
     }
     std::string start_time = this->CTest->CurrentTime();
diff --git a/Source/CTest/cmCTestCoverageHandler.cxx b/Source/CTest/cmCTestCoverageHandler.cxx
index 9c66e73f3..43a2baec3 100644
--- a/Source/CTest/cmCTestCoverageHandler.cxx
+++ b/Source/CTest/cmCTestCoverageHandler.cxx
@@ -23,6 +23,7 @@
 #include "cmsys/RegularExpression.hxx"
 #include <algorithm>
 #include <chrono>
+#include <cstring>
 #include <iomanip>
 #include <iterator>
 #include <sstream>
@@ -196,10 +197,10 @@ bool cmCTestCoverageHandler::ShouldIDoCoverage(std::string const& file,
 
   for (cmsys::RegularExpression& rx : this->CustomCoverageExcludeRegex) {
     if (rx.find(file)) {
-      cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "  File "
-                           << file << " is excluded in CTestCustom.ctest"
-                           << std::endl;
-                         , this->Quiet);
+      cmCTestOptionalLog(
+        this->CTest, HANDLER_VERBOSE_OUTPUT,
+        "  File " << file << " is excluded in CTestCustom.ctest" << std::endl;
+        , this->Quiet);
       return false;
     }
   }
@@ -390,8 +391,8 @@ int cmCTestCoverageHandler::ProcessHandler()
 
   if (!this->StartResultingXML(cmCTest::PartCoverage, "Coverage",
                                covSumFile)) {
-    cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot open coverage summary file."
-                 << std::endl);
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Cannot open coverage summary file." << std::endl);
     return -1;
   }
   covSumFile.setf(std::ios::fixed, std::ios::floatfield);
@@ -428,9 +429,10 @@ int cmCTestCoverageHandler::ProcessHandler()
                        this->Quiet);
     file_count++;
     if (file_count % 50 == 0) {
-      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, " processed: "
-                           << file_count << " out of "
-                           << cont.TotalCoverage.size() << std::endl,
+      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                         " processed: " << file_count << " out of "
+                                        << cont.TotalCoverage.size()
+                                        << std::endl,
                          this->Quiet);
       cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "    ", this->Quiet);
     }
@@ -523,8 +525,9 @@ int cmCTestCoverageHandler::ProcessHandler()
     float cper = 0;
     float cmet = 0;
     if (tested + untested > 0) {
-      cper = (100 * SAFEDIV(static_cast<float>(tested),
-                            static_cast<float>(tested + untested)));
+      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)));
     }
@@ -628,14 +631,14 @@ int cmCTestCoverageHandler::ProcessHandler()
   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
@@ -676,9 +679,9 @@ void cmCTestCoverageHandler::PopulateCustomVectors(cmMakefile* mf)
 // Compare file names: fnc(fn1) == fnc(fn2) // fnc == file name compare
 //
 #ifdef _WIN32
-#define fnc(s) cmSystemTools::LowerCase(s)
+#  define fnc(s) cmSystemTools::LowerCase(s)
 #else
-#define fnc(s) s
+#  define fnc(s) s
 #endif
 
 bool IsFileInDir(const std::string& infile, const std::string& indir)
@@ -927,7 +930,8 @@ int cmCTestCoverageHandler::HandleGCovCoverage(
   std::string gcovCommand =
     this->CTest->GetCTestConfiguration("CoverageCommand");
   if (gcovCommand.empty()) {
-    cmCTestLog(this->CTest, WARNING, "Could not find gcov." << std::endl);
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       "Could not find gcov." << std::endl, this->Quiet);
     return 0;
   }
   std::string gcovExtraFlags =
@@ -975,7 +979,12 @@ int cmCTestCoverageHandler::HandleGCovCoverage(
 
   std::string testingDir = this->CTest->GetBinaryDir() + "/Testing";
   std::string tempDir = testingDir + "/CoverageInfo";
-  cmSystemTools::MakeDirectory(tempDir);
+  if (!cmSystemTools::MakeDirectory(tempDir)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Unable to make directory: " << tempDir << std::endl);
+    cont->Error++;
+    return 0;
+  }
   cmWorkingDirectory workdir(tempDir);
 
   int gcovStyle = 0;
@@ -1038,7 +1047,8 @@ int cmCTestCoverageHandler::HandleGCovCoverage(
       continue;
     }
     if (retVal != 0) {
-      cmCTestLog(this->CTest, ERROR_MESSAGE, "Coverage command returned: "
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "Coverage command returned: "
                    << retVal << " while processing: " << f << std::endl);
       cmCTestLog(this->CTest, ERROR_MESSAGE,
                  "Command produced error: " << cont->Error << std::endl);
@@ -1070,8 +1080,8 @@ int cmCTestCoverageHandler::HandleGCovCoverage(
           gcovStyle = 1;
         }
         if (gcovStyle != 1) {
-          cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style e1"
-                       << std::endl);
+          cmCTestLog(this->CTest, ERROR_MESSAGE,
+                     "Unknown gcov output style e1" << std::endl);
           cont->Error++;
           break;
         }
@@ -1083,8 +1093,8 @@ int cmCTestCoverageHandler::HandleGCovCoverage(
           gcovStyle = 1;
         }
         if (gcovStyle != 1) {
-          cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style e2"
-                       << std::endl);
+          cmCTestLog(this->CTest, ERROR_MESSAGE,
+                     "Unknown gcov output style e2" << std::endl);
           cont->Error++;
           break;
         }
@@ -1095,8 +1105,8 @@ int cmCTestCoverageHandler::HandleGCovCoverage(
           gcovStyle = 2;
         }
         if (gcovStyle != 2) {
-          cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style e3"
-                       << std::endl);
+          cmCTestLog(this->CTest, ERROR_MESSAGE,
+                     "Unknown gcov output style e3" << std::endl);
           cont->Error++;
           break;
         }
@@ -1108,8 +1118,8 @@ int cmCTestCoverageHandler::HandleGCovCoverage(
           gcovStyle = 2;
         }
         if (gcovStyle != 2) {
-          cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style e4"
-                       << std::endl);
+          cmCTestLog(this->CTest, ERROR_MESSAGE,
+                     "Unknown gcov output style e4" << std::endl);
           cont->Error++;
           break;
         }
@@ -1118,8 +1128,8 @@ int cmCTestCoverageHandler::HandleGCovCoverage(
           gcovStyle = 2;
         }
         if (gcovStyle != 2) {
-          cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style e5"
-                       << std::endl);
+          cmCTestLog(this->CTest, ERROR_MESSAGE,
+                     "Unknown gcov output style e5" << std::endl);
           cont->Error++;
           break;
         }
@@ -1130,8 +1140,8 @@ int cmCTestCoverageHandler::HandleGCovCoverage(
           gcovStyle = 2;
         }
         if (gcovStyle != 2) {
-          cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style e6"
-                       << std::endl);
+          cmCTestLog(this->CTest, ERROR_MESSAGE,
+                     "Unknown gcov output style e6" << std::endl);
           cont->Error++;
           break;
         }
@@ -1145,37 +1155,40 @@ int cmCTestCoverageHandler::HandleGCovCoverage(
           gcovStyle = 2;
         }
         if (gcovStyle != 2) {
-          cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style e7"
-                       << std::endl);
+          cmCTestLog(this->CTest, ERROR_MESSAGE,
+                     "Unknown gcov output style e7" << std::endl);
           cont->Error++;
           break;
         }
 
-        cmCTestOptionalLog(this->CTest, WARNING, "Warning: Cannot open file: "
-                             << st2re5.match(1) << std::endl,
+        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) {
           gcovStyle = 2;
         }
         if (gcovStyle != 2) {
-          cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style e8"
-                       << std::endl);
+          cmCTestLog(this->CTest, ERROR_MESSAGE,
+                     "Unknown gcov output style e8" << std::endl);
           cont->Error++;
           break;
         }
 
-        cmCTestOptionalLog(this->CTest, WARNING, "Warning: File: "
-                             << st2re6.match(1) << " is newer than "
-                             << st2re6.match(2) << std::endl,
+        cmCTestOptionalLog(this->CTest, WARNING,
+                           "Warning: File: " << 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);
+          cmCTestLog(this->CTest, ERROR_MESSAGE,
+                     "Unknown gcov output line: [" << line << "]"
+                                                   << std::endl);
           cont->Error++;
           // abort();
         }
@@ -1376,6 +1389,14 @@ int cmCTestCoverageHandler::HandleLCovCoverage(
                        this->Quiet);
     std::string fileDir = cmSystemTools::GetFilenamePath(f);
     cmWorkingDirectory workdir(fileDir);
+    if (workdir.Failed()) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "Unable to change working directory to "
+                   << fileDir << " : "
+                   << std::strerror(workdir.GetLastResult()) << std::endl);
+      cont->Error++;
+      continue;
+    }
 
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
                        "Current coverage dir: " << fileDir << std::endl,
@@ -1403,7 +1424,8 @@ int cmCTestCoverageHandler::HandleLCovCoverage(
       continue;
     }
     if (retVal != 0) {
-      cmCTestLog(this->CTest, ERROR_MESSAGE, "Coverage command returned: "
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "Coverage command returned: "
                    << retVal << " while processing: " << f << std::endl);
       cmCTestLog(this->CTest, ERROR_MESSAGE,
                  "Command produced error: " << cont->Error << std::endl);
@@ -1600,6 +1622,12 @@ bool cmCTestCoverageHandler::FindLCovFiles(std::vector<std::string>& files)
   gl.RecurseThroughSymlinksOff();
   std::string buildDir = this->CTest->GetCTestConfiguration("BuildDirectory");
   cmWorkingDirectory workdir(buildDir);
+  if (workdir.Failed()) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Unable to change working directory to " << buildDir
+                                                        << std::endl);
+    return false;
+  }
 
   // Run profmerge to merge all *.dyn files into dpi files
   if (!cmSystemTools::RunSingleCommand("profmerge")) {
@@ -1796,7 +1824,8 @@ int cmCTestCoverageHandler::RunBullseyeCoverageBranch(
                      "run covbr: " << std::endl, this->Quiet);
 
   if (!this->RunBullseyeCommand(cont, "covbr", nullptr, outputFile)) {
-    cmCTestLog(this->CTest, ERROR_MESSAGE, "error running covbr for."
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "error running covbr for."
                  << "\n");
     return -1;
   }
@@ -1960,8 +1989,8 @@ int cmCTestCoverageHandler::RunBullseyeSourceSummary(
   cmXMLWriter xml(covSumFile);
   if (!this->StartResultingXML(cmCTest::PartCoverage, "Coverage",
                                covSumFile)) {
-    cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot open coverage summary file."
-                 << std::endl);
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Cannot open coverage summary file." << std::endl);
     return 0;
   }
   this->CTest->StartXML(xml, this->AppendXML);
@@ -2177,7 +2206,8 @@ bool cmCTestCoverageHandler::ParseBullsEyeCovsrcLine(
   }
   // should be at the end now
   if (pos != std::string::npos) {
-    cmCTestLog(this->CTest, ERROR_MESSAGE, "Error parsing input : "
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Error parsing input : "
                  << inputLine << " last pos not npos =  " << pos << "\n");
   }
   return true;
diff --git a/Source/CTest/cmCTestCurl.cxx b/Source/CTest/cmCTestCurl.cxx
index 7b5ea6005..6eb43546d 100644
--- a/Source/CTest/cmCTestCurl.cxx
+++ b/Source/CTest/cmCTestCurl.cxx
@@ -3,6 +3,7 @@
 #include "cmCTestCurl.h"
 
 #include "cmCTest.h"
+#include "cmCurl.h"
 #include "cmSystemTools.h"
 
 #include <ostream>
@@ -76,6 +77,7 @@ bool cmCTestCurl::InitCurl()
   if (!this->Curl) {
     return false;
   }
+  cmCurlSetCAInfo(this->Curl);
   if (this->VerifyPeerOff) {
     curl_easy_setopt(this->Curl, CURLOPT_SSL_VERIFYPEER, 0);
   }
@@ -146,7 +148,7 @@ bool cmCTestCurl::UploadFile(std::string const& local_file,
     ::curl_slist_append(nullptr, "Content-Type: text/xml");
   // Add any additional headers that the user specified.
   for (std::string const& h : this->HttpHeaders) {
-    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+    cmCTestOptionalLog(this->CTest, DEBUG,
                        "   Add HTTP Header: \"" << h << "\"" << std::endl,
                        this->Quiet);
     headers = ::curl_slist_append(headers, h.c_str());
@@ -175,7 +177,8 @@ bool cmCTestCurl::UploadFile(std::string const& local_file,
                        "Curl debug: [" << curlDebug << "]\n", this->Quiet);
   }
   if (response.empty()) {
-    cmCTestLog(this->CTest, ERROR_MESSAGE, "No response from server.\n"
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "No response from server.\n"
                  << curlDebug);
     return false;
   }
@@ -186,7 +189,8 @@ bool cmCTestCurl::HttpRequest(std::string const& url,
                               std::string const& fields, std::string& response)
 {
   response.clear();
-  cmCTestOptionalLog(this->CTest, DEBUG, "HttpRequest\n"
+  cmCTestOptionalLog(this->CTest, DEBUG,
+                     "HttpRequest\n"
                        << "url: " << url << "\n"
                        << "fields " << fields << "\n",
                      this->Quiet);
@@ -212,7 +216,7 @@ bool cmCTestCurl::HttpRequest(std::string const& url,
   struct curl_slist* headers = nullptr;
   if (!this->HttpHeaders.empty()) {
     for (std::string const& h : this->HttpHeaders) {
-      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+      cmCTestOptionalLog(this->CTest, DEBUG,
                          "   Add HTTP Header: \"" << h << "\"" << std::endl,
                          this->Quiet);
       headers = ::curl_slist_append(headers, h.c_str());
diff --git a/Source/CTest/cmCTestCurl.h b/Source/CTest/cmCTestCurl.h
index 427a39232..86d948995 100644
--- a/Source/CTest/cmCTestCurl.h
+++ b/Source/CTest/cmCTestCurl.h
@@ -16,7 +16,7 @@ class cmCTestCurl
 public:
   cmCTestCurl(cmCTest*);
   ~cmCTestCurl();
-  bool UploadFile(std::string const& url, std::string const& file,
+  bool UploadFile(std::string const& local_file, std::string const& url,
                   std::string const& fields, std::string& response);
   bool HttpRequest(std::string const& url, std::string const& fields,
                    std::string& response);
diff --git a/Source/CTest/cmCTestGIT.cxx b/Source/CTest/cmCTestGIT.cxx
index e85af5edb..b919c7934 100644
--- a/Source/CTest/cmCTestGIT.cxx
+++ b/Source/CTest/cmCTestGIT.cxx
@@ -70,8 +70,9 @@ std::string cmCTestGIT::GetWorkingRevision()
 bool cmCTestGIT::NoteOldRevision()
 {
   this->OldRevision = this->GetWorkingRevision();
-  cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Old revision of repository is: "
-               << this->OldRevision << "\n");
+  cmCTestLog(this->CTest, HANDLER_OUTPUT,
+             "   Old revision of repository is: " << this->OldRevision
+                                                  << "\n");
   this->PriorRev.Rev = this->OldRevision;
   return true;
 }
@@ -79,8 +80,9 @@ bool cmCTestGIT::NoteOldRevision()
 bool cmCTestGIT::NoteNewRevision()
 {
   this->NewRevision = this->GetWorkingRevision();
-  cmCTestLog(this->CTest, HANDLER_OUTPUT, "   New revision of repository is: "
-               << this->NewRevision << "\n");
+  cmCTestLog(this->CTest, HANDLER_OUTPUT,
+             "   New revision of repository is: " << this->NewRevision
+                                                  << "\n");
   return true;
 }
 
diff --git a/Source/CTest/cmCTestGenericHandler.cxx b/Source/CTest/cmCTestGenericHandler.cxx
index ce8f70998..dc1bba051 100644
--- a/Source/CTest/cmCTestGenericHandler.cxx
+++ b/Source/CTest/cmCTestGenericHandler.cxx
@@ -100,8 +100,9 @@ bool cmCTestGenericHandler::StartResultingXML(cmCTest::Part part,
   }
   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);
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Cannot create resulting XML file: " << ostr.str()
+                                                    << std::endl);
     return false;
   }
   this->CTest->AddSubmitFile(part, ostr.str().c_str());
diff --git a/Source/CTest/cmCTestGenericHandler.h b/Source/CTest/cmCTestGenericHandler.h
index e881252c9..cf91b4fa6 100644
--- a/Source/CTest/cmCTestGenericHandler.h
+++ b/Source/CTest/cmCTestGenericHandler.h
@@ -25,7 +25,7 @@ class cmCTestGenericHandler
 {
 public:
   /**
-   * If verbose then more informaiton is printed out
+   * If verbose then more information is printed out
    */
   void SetVerbose(bool val)
   {
diff --git a/Source/CTest/cmCTestHG.cxx b/Source/CTest/cmCTestHG.cxx
index 525dacc1d..c3c5da460 100644
--- a/Source/CTest/cmCTestHG.cxx
+++ b/Source/CTest/cmCTestHG.cxx
@@ -107,8 +107,9 @@ std::string cmCTestHG::GetWorkingRevision()
 bool cmCTestHG::NoteOldRevision()
 {
   this->OldRevision = this->GetWorkingRevision();
-  cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Old revision of repository is: "
-               << this->OldRevision << "\n");
+  cmCTestLog(this->CTest, HANDLER_OUTPUT,
+             "   Old revision of repository is: " << this->OldRevision
+                                                  << "\n");
   this->PriorRev.Rev = this->OldRevision;
   return true;
 }
@@ -116,8 +117,9 @@ bool cmCTestHG::NoteOldRevision()
 bool cmCTestHG::NoteNewRevision()
 {
   this->NewRevision = this->GetWorkingRevision();
-  cmCTestLog(this->CTest, HANDLER_OUTPUT, "   New revision of repository is: "
-               << this->NewRevision << "\n");
+  cmCTestLog(this->CTest, HANDLER_OUTPUT,
+             "   New revision of repository is: " << this->NewRevision
+                                                  << "\n");
   return true;
 }
 
@@ -157,8 +159,9 @@ 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)
@@ -168,6 +171,7 @@ public:
     this->InitializeParser();
   }
   ~LogParser() override { this->CleanupParser(); }
+
 private:
   cmCTestHG* HG;
 
diff --git a/Source/CTest/cmCTestHandlerCommand.cxx b/Source/CTest/cmCTestHandlerCommand.cxx
index 5a7baf545..8863dc847 100644
--- a/Source/CTest/cmCTestHandlerCommand.cxx
+++ b/Source/CTest/cmCTestHandlerCommand.cxx
@@ -9,6 +9,7 @@
 #include "cmWorkingDirectory.h"
 #include "cmake.h"
 
+#include <cstring>
 #include <sstream>
 #include <stdlib.h>
 
@@ -157,13 +158,14 @@ bool cmCTestHandlerCommand::InitialPass(std::vector<std::string> const& args,
         "BuildDirectory", cmSystemTools::CollapseFullPath(bdir).c_str(),
         this->Quiet);
     } else {
-      cmCTestLog(this->CTest, ERROR_MESSAGE, "CTEST_BINARY_DIRECTORY not set"
-                   << std::endl;);
+      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);
+    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(),
@@ -185,8 +187,9 @@ bool cmCTestHandlerCommand::InitialPass(std::vector<std::string> const& args,
   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);
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Cannot instantiate test handler " << this->GetName()
+                                                  << std::endl);
     if (capureCMakeError) {
       this->Makefile->AddDefinition(this->Values[ct_CAPTURE_CMAKE_ERROR],
                                     "-1");
@@ -218,6 +221,21 @@ bool cmCTestHandlerCommand::InitialPass(std::vector<std::string> const& args,
   }
   cmWorkingDirectory workdir(
     this->CTest->GetCTestConfiguration("BuildDirectory"));
+  if (workdir.Failed()) {
+    this->SetError("failed to change directory to " +
+                   this->CTest->GetCTestConfiguration("BuildDirectory") +
+                   " : " + std::strerror(workdir.GetLastResult()));
+    if (capureCMakeError) {
+      this->Makefile->AddDefinition(this->Values[ct_CAPTURE_CMAKE_ERROR],
+                                    "-1");
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 this->GetName() << " " << this->GetError() << "\n");
+      // return success because failure is recorded in CAPTURE_CMAKE_ERROR
+      return true;
+    }
+    return false;
+  }
+
   int res = handler->ProcessHandler();
   if (this->Values[ct_RETURN_VALUE] && *this->Values[ct_RETURN_VALUE]) {
     std::ostringstream str;
@@ -287,8 +305,8 @@ bool cmCTestHandlerCommand::CheckArgumentValue(std::string const& arg)
       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/cmCTestLaunch.cxx b/Source/CTest/cmCTestLaunch.cxx
index 30f76a927..0bffde3dc 100644
--- a/Source/CTest/cmCTestLaunch.cxx
+++ b/Source/CTest/cmCTestLaunch.cxx
@@ -21,9 +21,9 @@
 #include "cmake.h"
 
 #ifdef _WIN32
-#include <fcntl.h> // for _O_BINARY
-#include <io.h>    // for _setmode
-#include <stdio.h> // for std{out,err} and fileno
+#  include <fcntl.h> // for _O_BINARY
+#  include <io.h>    // for _setmode
+#  include <stdio.h> // for std{out,err} and fileno
 #endif
 
 cmCTestLaunch::cmCTestLaunch(int argc, const char* const* argv)
@@ -347,28 +347,27 @@ void cmCTestLaunch::WriteXML()
   // Use cmGeneratedFileStream to atomically create the report file.
   cmGeneratedFileStream fxml(logXML.c_str());
   cmXMLWriter xml(fxml, 2);
-  xml.StartElement("Failure");
-  xml.Attribute("type", this->IsError() ? "Error" : "Warning");
-  this->WriteXMLAction(xml);
-  this->WriteXMLCommand(xml);
-  this->WriteXMLResult(xml);
-  this->WriteXMLLabels(xml);
-  xml.EndElement(); // Failure
+  cmXMLElement e2(xml, "Failure");
+  e2.Attribute("type", this->IsError() ? "Error" : "Warning");
+  this->WriteXMLAction(e2);
+  this->WriteXMLCommand(e2);
+  this->WriteXMLResult(e2);
+  this->WriteXMLLabels(e2);
 }
 
-void cmCTestLaunch::WriteXMLAction(cmXMLWriter& xml)
+void cmCTestLaunch::WriteXMLAction(cmXMLElement& e2)
 {
-  xml.Comment("Meta-information about the build action");
-  xml.StartElement("Action");
+  e2.Comment("Meta-information about the build action");
+  cmXMLElement e3(e2, "Action");
 
   // TargetName
   if (!this->OptionTargetName.empty()) {
-    xml.Element("TargetName", this->OptionTargetName);
+    e3.Element("TargetName", this->OptionTargetName);
   }
 
   // Language
   if (!this->OptionLanguage.empty()) {
-    xml.Element("Language", this->OptionLanguage);
+    e3.Element("Language", this->OptionLanguage);
   }
 
   // SourceFile
@@ -383,12 +382,12 @@ void cmCTestLaunch::WriteXMLAction(cmXMLWriter& xml)
       source = cmSystemTools::RelativePath(this->SourceDir, source);
     }
 
-    xml.Element("SourceFile", source);
+    e3.Element("SourceFile", source);
   }
 
   // OutputFile
   if (!this->OptionOutput.empty()) {
-    xml.Element("OutputFile", this->OptionOutput);
+    e3.Element("OutputFile", this->OptionOutput);
   }
 
   // OutputType
@@ -407,97 +406,88 @@ void cmCTestLaunch::WriteXMLAction(cmXMLWriter& xml)
     outputType = "object file";
   }
   if (outputType) {
-    xml.Element("OutputType", outputType);
+    e3.Element("OutputType", outputType);
   }
-
-  xml.EndElement(); // Action
 }
 
-void cmCTestLaunch::WriteXMLCommand(cmXMLWriter& xml)
+void cmCTestLaunch::WriteXMLCommand(cmXMLElement& e2)
 {
-  xml.Comment("Details of command");
-  xml.StartElement("Command");
+  e2.Comment("Details of command");
+  cmXMLElement e3(e2, "Command");
   if (!this->CWD.empty()) {
-    xml.Element("WorkingDirectory", this->CWD);
+    e3.Element("WorkingDirectory", this->CWD);
   }
   for (std::string const& realArg : this->RealArgs) {
-    xml.Element("Argument", realArg);
+    e3.Element("Argument", realArg);
   }
-  xml.EndElement(); // Command
 }
 
-void cmCTestLaunch::WriteXMLResult(cmXMLWriter& xml)
+void cmCTestLaunch::WriteXMLResult(cmXMLElement& e2)
 {
-  xml.Comment("Result of command");
-  xml.StartElement("Result");
+  e2.Comment("Result of command");
+  cmXMLElement e3(e2, "Result");
 
   // StdOut
-  xml.StartElement("StdOut");
-  this->DumpFileToXML(xml, this->LogOut);
-  xml.EndElement(); // StdOut
+  this->DumpFileToXML(e3, "StdOut", this->LogOut);
 
   // StdErr
-  xml.StartElement("StdErr");
-  this->DumpFileToXML(xml, this->LogErr);
-  xml.EndElement(); // StdErr
+  this->DumpFileToXML(e3, "StdErr", this->LogErr);
 
   // ExitCondition
-  xml.StartElement("ExitCondition");
+  cmXMLElement e4(e3, "ExitCondition");
   cmsysProcess* cp = this->Process;
   switch (cmsysProcess_GetState(cp)) {
     case cmsysProcess_State_Starting:
-      xml.Content("No process has been executed");
+      e4.Content("No process has been executed");
       break;
     case cmsysProcess_State_Executing:
-      xml.Content("The process is still executing");
+      e4.Content("The process is still executing");
       break;
     case cmsysProcess_State_Disowned:
-      xml.Content("Disowned");
+      e4.Content("Disowned");
       break;
     case cmsysProcess_State_Killed:
-      xml.Content("Killed by parent");
+      e4.Content("Killed by parent");
       break;
 
     case cmsysProcess_State_Expired:
-      xml.Content("Killed when timeout expired");
+      e4.Content("Killed when timeout expired");
       break;
     case cmsysProcess_State_Exited:
-      xml.Content(this->ExitCode);
+      e4.Content(this->ExitCode);
       break;
     case cmsysProcess_State_Exception:
-      xml.Content("Terminated abnormally: ");
-      xml.Content(cmsysProcess_GetExceptionString(cp));
+      e4.Content("Terminated abnormally: ");
+      e4.Content(cmsysProcess_GetExceptionString(cp));
       break;
     case cmsysProcess_State_Error:
-      xml.Content("Error administrating child process: ");
-      xml.Content(cmsysProcess_GetErrorString(cp));
+      e4.Content("Error administrating child process: ");
+      e4.Content(cmsysProcess_GetErrorString(cp));
       break;
-  };
-  xml.EndElement(); // ExitCondition
-
-  xml.EndElement(); // Result
+  }
 }
 
-void cmCTestLaunch::WriteXMLLabels(cmXMLWriter& xml)
+void cmCTestLaunch::WriteXMLLabels(cmXMLElement& e2)
 {
   this->LoadLabels();
   if (!this->Labels.empty()) {
-    xml.Comment("Interested parties");
-    xml.StartElement("Labels");
+    e2.Comment("Interested parties");
+    cmXMLElement e3(e2, "Labels");
     for (std::string const& label : this->Labels) {
-      xml.Element("Label", label);
+      e3.Element("Label", label);
     }
-    xml.EndElement(); // Labels
   }
 }
 
-void cmCTestLaunch::DumpFileToXML(cmXMLWriter& xml, std::string const& fname)
+void cmCTestLaunch::DumpFileToXML(cmXMLElement& e3, const char* tag,
+                                  std::string const& fname)
 {
   cmsys::ifstream fin(fname.c_str(), std::ios::in | std::ios::binary);
 
   std::string line;
   const char* sep = "";
 
+  cmXMLElement e4(e3, tag);
   while (cmSystemTools::GetLineFromStream(fin, line)) {
     if (MatchesFilterPrefix(line)) {
       continue;
@@ -507,8 +497,8 @@ void cmCTestLaunch::DumpFileToXML(cmXMLWriter& xml, std::string const& fname)
     } else if (this->Match(line, this->RegexWarning)) {
       line = "[CTest: warning matched] " + line;
     }
-    xml.Content(sep);
-    xml.Content(line);
+    e4.Content(sep);
+    e4.Content(line);
     sep = "\n";
   }
 }
diff --git a/Source/CTest/cmCTestLaunch.h b/Source/CTest/cmCTestLaunch.h
index 29986ff60..debbe59d7 100644
--- a/Source/CTest/cmCTestLaunch.h
+++ b/Source/CTest/cmCTestLaunch.h
@@ -10,7 +10,7 @@
 #include <string>
 #include <vector>
 
-class cmXMLWriter;
+class cmXMLElement;
 
 /** \class cmCTestLaunch
  * \brief Launcher for make rules to report results for ctest
@@ -89,11 +89,11 @@ private:
 
   // Methods to generate the xml fragment.
   void WriteXML();
-  void WriteXMLAction(cmXMLWriter& xml);
-  void WriteXMLCommand(cmXMLWriter& xml);
-  void WriteXMLResult(cmXMLWriter& xml);
-  void WriteXMLLabels(cmXMLWriter& xml);
-  void DumpFileToXML(cmXMLWriter& xml, std::string const& fname);
+  void WriteXMLAction(cmXMLElement&);
+  void WriteXMLCommand(cmXMLElement&);
+  void WriteXMLResult(cmXMLElement&);
+  void WriteXMLLabels(cmXMLElement&);
+  void DumpFileToXML(cmXMLElement&, const char* tag, std::string const& fname);
 
   // Configuration
   void LoadConfig();
diff --git a/Source/CTest/cmCTestMemCheckHandler.cxx b/Source/CTest/cmCTestMemCheckHandler.cxx
index cb1d947c8..04d1839ab 100644
--- a/Source/CTest/cmCTestMemCheckHandler.cxx
+++ b/Source/CTest/cmCTestMemCheckHandler.cxx
@@ -37,8 +37,9 @@ static CatToErrorType cmCTestMemCheckBoundsChecker[] = {
 static void xmlReportError(int line, const char* msg, void* data)
 {
   cmCTest* ctest = static_cast<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
@@ -366,10 +367,10 @@ void cmCTestMemCheckHandler::GenerateDartOutput(cmXMLWriter& xml)
       const int maxTestNameWidth = this->CTest->GetMaxTestNameWidth();
       std::string outname = result.Name + " ";
       outname.resize(maxTestNameWidth + 4, '.');
-      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, cc + 1
-                           << "/" << total << " MemCheck: #"
-                           << result.TestCount << ": " << outname
-                           << "   Defects: " << memoryErrors << std::endl,
+      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                         cc + 1 << "/" << total << " MemCheck: #"
+                                << result.TestCount << ": " << outname
+                                << "   Defects: " << memoryErrors << std::endl,
                          this->Quiet);
     }
     xml.StartElement("Log");
@@ -773,8 +774,9 @@ bool cmCTestMemCheckHandler::ProcessMemCheckPurifyOutput(
         }
       }
       if (cc == this->ResultStrings.size()) {
-        cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown Purify memory fault: "
-                     << pfW.match(1) << std::endl);
+        cmCTestLog(this->CTest, ERROR_MESSAGE,
+                   "Unknown Purify memory fault: " << pfW.match(1)
+                                                   << std::endl);
         ostr << "*** Unknown Purify memory fault: " << pfW.match(1)
              << std::endl;
       }
@@ -918,11 +920,12 @@ bool cmCTestMemCheckHandler::ProcessMemCheckValgrindOutput(
       break; // stop the copy of output if we are full
     }
   }
-  cmCTestOptionalLog(
-    this->CTest, DEBUG, "End test (elapsed: "
-      << cmDurationTo<unsigned int>(std::chrono::steady_clock::now() - sttime)
-      << "s)" << std::endl,
-    this->Quiet);
+  cmCTestOptionalLog(this->CTest, DEBUG,
+                     "End test (elapsed: "
+                       << cmDurationTo<unsigned int>(
+                            std::chrono::steady_clock::now() - sttime)
+                       << "s)" << std::endl,
+                     this->Quiet);
   log = ostr.str();
   this->DefectCount += defects;
   return defects == 0;
@@ -963,11 +966,12 @@ bool cmCTestMemCheckHandler::ProcessMemCheckBoundsCheckerOutput(
     results[err]++;
     defects++;
   }
-  cmCTestOptionalLog(
-    this->CTest, DEBUG, "End test (elapsed: "
-      << cmDurationTo<unsigned int>(std::chrono::steady_clock::now() - sttime)
-      << "s)" << std::endl,
-    this->Quiet);
+  cmCTestOptionalLog(this->CTest, DEBUG,
+                     "End test (elapsed: "
+                       << cmDurationTo<unsigned int>(
+                            std::chrono::steady_clock::now() - sttime)
+                       << "s)" << std::endl,
+                     this->Quiet);
   if (defects) {
     // only put the output of Bounds Checker if there were
     // errors or leaks detected
diff --git a/Source/CTest/cmCTestMemCheckHandler.h b/Source/CTest/cmCTestMemCheckHandler.h
index 921829429..8880dac9a 100644
--- a/Source/CTest/cmCTestMemCheckHandler.h
+++ b/Source/CTest/cmCTestMemCheckHandler.h
@@ -127,7 +127,7 @@ private:
 
   //! Parse Valgrind/Purify/Bounds Checker result out of the output
   // string. After running, log holds the output and results hold the
-  // different memmory errors.
+  // different memory errors.
   bool ProcessMemCheckOutput(const std::string& str, std::string& log,
                              std::vector<int>& results);
   bool ProcessMemCheckValgrindOutput(const std::string& str, std::string& log,
diff --git a/Source/CTest/cmCTestMultiProcessHandler.cxx b/Source/CTest/cmCTestMultiProcessHandler.cxx
index 50c2d86d7..dcef8a037 100644
--- a/Source/CTest/cmCTestMultiProcessHandler.cxx
+++ b/Source/CTest/cmCTestMultiProcessHandler.cxx
@@ -2,6 +2,7 @@
    file Copyright.txt or https://cmake.org/licensing for details.  */
 #include "cmCTestMultiProcessHandler.h"
 
+#include "cmAffinity.h"
 #include "cmCTest.h"
 #include "cmCTestRunTest.h"
 #include "cmCTestScriptHandler.h"
@@ -19,6 +20,7 @@
 
 #include <algorithm>
 #include <chrono>
+#include <cstring>
 #include <iomanip>
 #include <list>
 #include <math.h>
@@ -53,6 +55,8 @@ cmCTestMultiProcessHandler::cmCTestMultiProcessHandler()
   this->TestLoad = 0;
   this->Completed = 0;
   this->RunningCount = 0;
+  this->ProcessorsAvailable = cmAffinity::GetProcessorsAvailable();
+  this->HaveAffinity = this->ProcessorsAvailable.size();
   this->StopTimePassed = false;
   this->HasCycles = false;
   this->SerialTestRunning = false;
@@ -120,13 +124,29 @@ bool cmCTestMultiProcessHandler::StartTestProcess(int test)
   std::chrono::system_clock::time_point stop_time = this->CTest->GetStopTime();
   if (stop_time != std::chrono::system_clock::time_point() &&
       stop_time <= std::chrono::system_clock::now()) {
-    cmCTestLog(this->CTest, ERROR_MESSAGE, "The stop time has been passed. "
-                                           "Stopping all tests."
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "The stop time has been passed. "
+               "Stopping all tests."
                  << std::endl);
     this->StopTimePassed = true;
     return false;
   }
 
+  if (this->HaveAffinity && this->Properties[test]->WantAffinity) {
+    size_t needProcessors = this->GetProcessorsUsed(test);
+    if (needProcessors > this->ProcessorsAvailable.size()) {
+      return false;
+    }
+    std::vector<size_t> affinity;
+    affinity.reserve(needProcessors);
+    for (size_t i = 0; i < needProcessors; ++i) {
+      auto p = this->ProcessorsAvailable.begin();
+      affinity.push_back(*p);
+      this->ProcessorsAvailable.erase(p);
+    }
+    this->Properties[test]->Affinity = std::move(affinity);
+  }
+
   cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
                      "test " << test << "\n", this->Quiet);
   this->TestRunningMap[test] = true; // mark the test as running
@@ -151,13 +171,19 @@ bool cmCTestMultiProcessHandler::StartTestProcess(int test)
     }
   }
 
-  cmWorkingDirectory workdir(this->Properties[test]->Directory);
-
-  // Lock the resources we'll be using
+  // Always lock the resources we'll be using, even if we fail to set the
+  // working directory because FinishTestProcess() will try to unlock them
   this->LockResources(test);
 
-  if (testRun->StartTest(this->Total)) {
-    return true;
+  cmWorkingDirectory workdir(this->Properties[test]->Directory);
+  if (workdir.Failed()) {
+    testRun->StartFailure("Failed to change working directory to " +
+                          this->Properties[test]->Directory + " : " +
+                          std::strerror(workdir.GetLastResult()));
+  } else {
+    if (testRun->StartTest(this->Total)) {
+      return true;
+    }
   }
 
   this->FinishTestProcess(testRun, false);
@@ -200,6 +226,11 @@ inline size_t cmCTestMultiProcessHandler::GetProcessorsUsed(int test)
   if (processors > this->ParallelLevel) {
     processors = this->ParallelLevel;
   }
+  // Cap tests that want affinity to the maximum affinity available.
+  if (this->HaveAffinity && processors > this->HaveAffinity &&
+      this->Properties[test]->WantAffinity) {
+    processors = this->HaveAffinity;
+  }
   return processors;
 }
 
@@ -300,10 +331,10 @@ void cmCTestMultiProcessHandler::StartNextTests()
     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);
+        cmCTestLog(this->CTest, DEBUG,
+                   "OK to run " << GetName(test) << ", it requires "
+                                << processors << " procs & system load is: "
+                                << systemLoad << std::endl);
         allTestsFailedTestLoadCheck = false;
       } else {
         testLoadOk = false;
@@ -398,6 +429,11 @@ void cmCTestMultiProcessHandler::FinishTestProcess(cmCTestRunTest* runner,
   this->UnlockResources(test);
   this->RunningCount -= GetProcessorsUsed(test);
 
+  for (auto p : properties->Affinity) {
+    this->ProcessorsAvailable.insert(p);
+  }
+  properties->Affinity.clear();
+
   delete runner;
   if (started) {
     this->StartNextTests();
@@ -666,6 +702,8 @@ void cmCTestMultiProcessHandler::PrintTestList()
     count++;
     cmCTestTestHandler::cmCTestTestProperties& p = *it.second;
 
+    // Don't worry if this fails, we are only showing the test list, not
+    // running the tests
     cmWorkingDirectory workdir(p.Directory);
 
     cmCTestRunTest testRun(*this);
@@ -675,8 +713,8 @@ void cmCTestMultiProcessHandler::PrintTestList()
 
     if (!p.Labels.empty()) // print the labels
     {
-      cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Labels:",
-                         this->Quiet);
+      cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                         "Labels:", this->Quiet);
     }
     for (std::string const& label : p.Labels) {
       cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, " " << label,
@@ -710,7 +748,8 @@ void cmCTestMultiProcessHandler::PrintTestList()
     cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, std::endl, this->Quiet);
   }
 
-  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, std::endl
+  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                     std::endl
                        << "Total Tests: " << this->Total << std::endl,
                      this->Quiet);
 }
diff --git a/Source/CTest/cmCTestMultiProcessHandler.h b/Source/CTest/cmCTestMultiProcessHandler.h
index 7837ff910..203170e13 100644
--- a/Source/CTest/cmCTestMultiProcessHandler.h
+++ b/Source/CTest/cmCTestMultiProcessHandler.h
@@ -74,6 +74,7 @@ public:
   cmCTestTestHandler* GetTestHandler() { return this->TestHandler; }
 
   void SetQuiet(bool b) { this->Quiet = b; }
+
 protected:
   // Start the next test or tests as many as are allowed by
   // ParallelLevel
@@ -119,6 +120,8 @@ protected:
   // Number of tests that are complete
   size_t Completed;
   size_t RunningCount;
+  std::set<size_t> ProcessorsAvailable;
+  size_t HaveAffinity;
   bool StopTimePassed;
   // list of test properties (indices concurrent to the test map)
   PropertiesMap Properties;
diff --git a/Source/CTest/cmCTestP4.cxx b/Source/CTest/cmCTestP4.cxx
index fdf893243..511dbd2ec 100644
--- a/Source/CTest/cmCTestP4.cxx
+++ b/Source/CTest/cmCTestP4.cxx
@@ -372,8 +372,9 @@ bool cmCTestP4::NoteOldRevision()
 {
   this->OldRevision = this->GetWorkingRevision();
 
-  cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Old revision of repository is: "
-               << this->OldRevision << "\n");
+  cmCTestLog(this->CTest, HANDLER_OUTPUT,
+             "   Old revision of repository is: " << this->OldRevision
+                                                  << "\n");
   this->PriorRev.Rev = this->OldRevision;
   return true;
 }
@@ -382,8 +383,9 @@ bool cmCTestP4::NoteNewRevision()
 {
   this->NewRevision = this->GetWorkingRevision();
 
-  cmCTestLog(this->CTest, HANDLER_OUTPUT, "   New revision of repository is: "
-               << this->NewRevision << "\n");
+  cmCTestLog(this->CTest, HANDLER_OUTPUT,
+             "   New revision of repository is: " << this->NewRevision
+                                                  << "\n");
   return true;
 }
 
@@ -398,7 +400,8 @@ bool 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>") {
-    cmCTestLog(this->CTest, HANDLER_OUTPUT, "   At least one of the revisions "
+    cmCTestLog(this->CTest, HANDLER_OUTPUT,
+               "   At least one of the revisions "
                  << "is unknown. No repository changes will be reported.\n");
     return false;
   }
diff --git a/Source/CTest/cmCTestRunTest.cxx b/Source/CTest/cmCTestRunTest.cxx
index 30ad38ca1..927797af0 100644
--- a/Source/CTest/cmCTestRunTest.cxx
+++ b/Source/CTest/cmCTestRunTest.cxx
@@ -14,6 +14,7 @@
 #include "cmsys/RegularExpression.hxx"
 #include <chrono>
 #include <cmAlgorithms.h>
+#include <cstring>
 #include <iomanip>
 #include <ratio>
 #include <sstream>
@@ -40,8 +41,8 @@ cmCTestRunTest::cmCTestRunTest(cmCTestMultiProcessHandler& multiHandler)
 
 void cmCTestRunTest::CheckOutput(std::string const& line)
 {
-  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";
 
@@ -49,7 +50,8 @@ void cmCTestRunTest::CheckOutput(std::string const& line)
   if (!this->TestProperties->TimeoutRegularExpressions.empty()) {
     for (auto& reg : this->TestProperties->TimeoutRegularExpressions) {
       if (reg.first.find(this->ProcessOutput.c_str())) {
-        cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, this->GetIndex()
+        cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                   this->GetIndex()
                      << ": "
                      << "Test timeout changed to "
                      << std::chrono::duration_cast<std::chrono::seconds>(
@@ -248,11 +250,7 @@ bool cmCTestRunTest::EndTest(size_t completed, size_t total, bool started)
     *this->TestHandler->LogFile << "Test time = " << buf << std::endl;
   }
 
-  // Set the working directory to the tests directory to process Dart files.
-  {
-    cmWorkingDirectory workdir(this->TestProperties->Directory);
-    this->DartProcessing();
-  }
+  this->DartProcessing();
 
   // if this is doing MemCheck then all the output needs to be put into
   // Output since that is what is parsed by cmCTestMemCheckHandler
@@ -338,6 +336,13 @@ bool cmCTestRunTest::StartAgain()
   this->RunAgain = false; // reset
   // change to tests directory
   cmWorkingDirectory workdir(this->TestProperties->Directory);
+  if (workdir.Failed()) {
+    this->StartFailure("Failed to change working directory to " +
+                       this->TestProperties->Directory + " : " +
+                       std::strerror(workdir.GetLastResult()));
+    return true;
+  }
+
   this->StartTest(this->TotalNumberOfTests);
   return true;
 }
@@ -376,21 +381,53 @@ void cmCTestRunTest::MemCheckPostProcess()
   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,
+  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);
   handler->PostProcessTest(this->TestResult, this->Index);
 }
 
+void cmCTestRunTest::StartFailure(std::string const& output)
+{
+  // Still need to log the Start message so the test summary records our
+  // attempt to start this test
+  cmCTestLog(this->CTest, HANDLER_OUTPUT,
+             std::setw(2 * getNumWidth(this->TotalNumberOfTests) + 8)
+               << "Start "
+               << std::setw(getNumWidth(this->TestHandler->GetMaxIndex()))
+               << this->TestProperties->Index << ": "
+               << this->TestProperties->Name << std::endl);
+
+  this->ProcessOutput.clear();
+  if (!output.empty()) {
+    *this->TestHandler->LogFile << output << std::endl;
+    cmCTestLog(this->CTest, ERROR_MESSAGE, output << std::endl);
+  }
+
+  this->TestResult.Properties = this->TestProperties;
+  this->TestResult.ExecutionTime = cmDuration::zero();
+  this->TestResult.CompressOutput = false;
+  this->TestResult.ReturnValue = -1;
+  this->TestResult.CompletionStatus = "Failed to start";
+  this->TestResult.Status = cmCTestTestHandler::NOT_RUN;
+  this->TestResult.TestCount = this->TestProperties->Index;
+  this->TestResult.Name = this->TestProperties->Name;
+  this->TestResult.Path = this->TestProperties->Directory;
+  this->TestResult.Output = output;
+  this->TestResult.FullCommandLine.clear();
+  this->TestProcess = cm::make_unique<cmProcess>(*this);
+}
+
 // Starts the execution of a test.  Returns once it has started
 bool cmCTestRunTest::StartTest(size_t total)
 {
   this->TotalNumberOfTests = total; // save for rerun case
-  cmCTestLog(this->CTest, HANDLER_OUTPUT, std::setw(2 * getNumWidth(total) + 8)
+  cmCTestLog(this->CTest, HANDLER_OUTPUT,
+             std::setw(2 * getNumWidth(total) + 8)
                << "Start "
                << std::setw(getNumWidth(this->TestHandler->GetMaxIndex()))
                << this->TestProperties->Index << ": "
@@ -515,12 +552,13 @@ bool cmCTestRunTest::StartTest(size_t total)
   }
 
   return this->ForkProcess(timeout, this->TestProperties->ExplicitTimeout,
-                           &this->TestProperties->Environment);
+                           &this->TestProperties->Environment,
+                           &this->TestProperties->Affinity);
 }
 
 void cmCTestRunTest::ComputeArguments()
 {
-  this->Arguments.clear(); // reset becaue this might be a rerun
+  this->Arguments.clear(); // reset because this might be a rerun
   std::vector<std::string>::const_iterator j =
     this->TestProperties->Args.begin();
   ++j; // skip test name
@@ -556,20 +594,21 @@ void cmCTestRunTest::ComputeArguments()
   this->TestResult.FullCommandLine = testCommand;
 
   // Print the test command in verbose mode
-  cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, std::endl
+  cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+             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.empty()) {
-    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, this->Index
-                 << ": "
-                 << "Environment variables: " << std::endl);
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+               this->Index << ": "
+                           << "Environment variables: " << std::endl);
   }
   for (std::string const& env : this->TestProperties->Environment) {
-    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, this->Index << ":  " << env
-                                                                << std::endl);
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+               this->Index << ":  " << env << std::endl);
   }
 }
 
@@ -591,7 +630,8 @@ void cmCTestRunTest::DartProcessing()
 }
 
 bool cmCTestRunTest::ForkProcess(cmDuration testTimeOut, bool explicitTimeout,
-                                 std::vector<std::string>* environment)
+                                 std::vector<std::string>* environment,
+                                 std::vector<size_t>* affinity)
 {
   this->TestProcess = cm::make_unique<cmProcess>(*this);
   this->TestProcess->SetId(this->Index);
@@ -621,10 +661,11 @@ bool cmCTestRunTest::ForkProcess(cmDuration testTimeOut, bool explicitTimeout,
   if (testTimeOut == cmDuration::zero() && explicitTimeout) {
     timeout = cmDuration::zero();
   }
-  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, this->Index
-                       << ": "
-                       << "Test timeout computed to be: "
-                       << cmDurationTo<unsigned int>(timeout) << "\n",
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     this->Index << ": "
+                                 << "Test timeout computed to be: "
+                                 << cmDurationTo<unsigned int>(timeout)
+                                 << "\n",
                      this->TestHandler->GetQuiet());
 
   this->TestProcess->SetTimeout(timeout);
@@ -637,7 +678,8 @@ bool cmCTestRunTest::ForkProcess(cmDuration testTimeOut, bool explicitTimeout,
     cmSystemTools::AppendEnv(*environment);
   }
 
-  return this->TestProcess->StartProcess(this->MultiTestHandler.Loop);
+  return this->TestProcess->StartProcess(this->MultiTestHandler.Loop,
+                                         affinity);
 }
 
 void cmCTestRunTest::WriteLogOutputTop(size_t completed, size_t total)
@@ -649,20 +691,20 @@ void cmCTestRunTest::WriteLogOutputTop(size_t completed, size_t total)
   // 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) {
-    cmCTestLog(this->CTest, HANDLER_OUTPUT, std::setw(getNumWidth(total))
-                 << completed << "/");
-    cmCTestLog(this->CTest, HANDLER_OUTPUT, std::setw(getNumWidth(total))
-                 << total << " ");
+    cmCTestLog(this->CTest, HANDLER_OUTPUT,
+               std::setw(getNumWidth(total)) << completed << "/");
+    cmCTestLog(this->CTest, HANDLER_OUTPUT,
+               std::setw(getNumWidth(total)) << total << " ");
   }
   // if this is one of several runs of a test just print blank space
   // to keep things neat
   else {
-    cmCTestLog(this->CTest, HANDLER_OUTPUT, std::setw(getNumWidth(total))
-                 << " "
-                 << " ");
-    cmCTestLog(this->CTest, HANDLER_OUTPUT, std::setw(getNumWidth(total))
-                 << " "
-                 << " ");
+    cmCTestLog(this->CTest, HANDLER_OUTPUT,
+               std::setw(getNumWidth(total)) << " "
+                                             << " ");
+    cmCTestLog(this->CTest, HANDLER_OUTPUT,
+               std::setw(getNumWidth(total)) << " "
+                                             << " ");
   }
 
   if (this->TestHandler->MemCheck) {
@@ -708,8 +750,8 @@ void cmCTestRunTest::WriteLogOutputTop(size_t completed, size_t total)
                               << 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 << " ... ");
 }
 
 void cmCTestRunTest::FinalizeTest()
diff --git a/Source/CTest/cmCTestRunTest.h b/Source/CTest/cmCTestRunTest.h
index 4d573572f..3b1d674da 100644
--- a/Source/CTest/cmCTestRunTest.h
+++ b/Source/CTest/cmCTestRunTest.h
@@ -74,6 +74,8 @@ public:
 
   bool StartAgain();
 
+  void StartFailure(std::string const& output);
+
   cmCTest* GetCTest() const { return this->CTest; }
 
   void FinalizeTest();
@@ -83,7 +85,8 @@ private:
   void DartProcessing();
   void ExeNotFound(std::string exe);
   bool ForkProcess(cmDuration testTimeOut, bool explicitTimeout,
-                   std::vector<std::string>* environment);
+                   std::vector<std::string>* environment,
+                   std::vector<size_t>* affinity);
   void WriteLogOutputTop(size_t completed, size_t total);
   // Run post processing of the process output for MemCheck
   void MemCheckPostProcess();
diff --git a/Source/CTest/cmCTestSVN.cxx b/Source/CTest/cmCTestSVN.cxx
index 73184fc05..58d9b3dcf 100644
--- a/Source/CTest/cmCTestSVN.cxx
+++ b/Source/CTest/cmCTestSVN.cxx
@@ -107,9 +107,10 @@ bool cmCTestSVN::NoteOldRevision()
     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
@@ -128,9 +129,10 @@ bool cmCTestSVN::NoteNewRevision()
     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
@@ -290,8 +292,9 @@ bool cmCTestSVN::RunSVNCommand(std::vector<char const*> const& parameters,
   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)
@@ -302,6 +305,7 @@ public:
     this->InitializeParser();
   }
   ~LogParser() override { this->CleanupParser(); }
+
 private:
   cmCTestSVN* SVN;
   cmCTestSVN::SVNInfo& SVNRepo;
diff --git a/Source/CTest/cmCTestScriptHandler.cxx b/Source/CTest/cmCTestScriptHandler.cxx
index e0bffd476..333c899be 100644
--- a/Source/CTest/cmCTestScriptHandler.cxx
+++ b/Source/CTest/cmCTestScriptHandler.cxx
@@ -39,9 +39,9 @@
 #include "cmake.h"
 
 #ifdef _WIN32
-#include <windows.h>
+#  include <windows.h>
 #else
-#include <unistd.h>
+#  include <unistd.h>
 #endif
 
 class cmExecutionStatus;
@@ -184,8 +184,9 @@ 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 =
@@ -210,8 +211,8 @@ int cmCTestScriptHandler::ExecuteScript(const std::string& total_script_arg)
   int pipe =
     cmSystemTools::WaitForLine(cp, line, std::chrono::seconds(100), out, err);
   while (pipe != cmsysProcess_Pipe_None) {
-    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Output: " << line
-                                                               << "\n");
+    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) {
@@ -230,17 +231,19 @@ int cmCTestScriptHandler::ExecuteScript(const std::string& total_script_arg)
     retVal = cmsysProcess_GetExitValue(cp);
   } else if (result == cmsysProcess_State_Exception) {
     retVal = cmsysProcess_GetExitException(cp);
-    cmCTestLog(this->CTest, ERROR_MESSAGE, "\tThere was an exception: "
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "\tThere was an exception: "
                  << cmsysProcess_GetExceptionString(cp) << " " << retVal
                  << std::endl);
     failed = true;
   } else if (result == cmsysProcess_State_Expired) {
-    cmCTestLog(this->CTest, ERROR_MESSAGE, "\tThere was a timeout"
-                 << std::endl);
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "\tThere was a timeout" << std::endl);
     failed = true;
   } else if (result == cmsysProcess_State_Error) {
-    cmCTestLog(this->CTest, ERROR_MESSAGE, "\tError executing ctest: "
-                 << cmsysProcess_GetErrorString(cp) << std::endl);
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "\tError executing ctest: " << cmsysProcess_GetErrorString(cp)
+                                           << std::endl);
     failed = true;
   }
   cmsysProcess_Delete(cp);
@@ -253,8 +256,8 @@ int cmCTestScriptHandler::ExecuteScript(const std::string& total_script_arg)
         message << arg << " ";
       }
     }
-    cmCTestLog(this->CTest, ERROR_MESSAGE, message.str() << argv[0]
-                                                         << std::endl);
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               message.str() << argv[0] << std::endl);
     return -1;
   }
   return retVal;
@@ -372,8 +375,8 @@ int cmCTestScriptHandler::ReadInScript(const std::string& total_script_arg)
     this->Makefile->GetModulesFile("CTestScriptMode.cmake");
   if (!this->Makefile->ReadListFile(systemFile.c_str()) ||
       cmSystemTools::GetErrorOccuredFlag()) {
-    cmCTestLog(this->CTest, ERROR_MESSAGE, "Error in read:" << systemFile
-                                                            << "\n");
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Error in read:" << systemFile << "\n");
     return 2;
   }
 
@@ -527,7 +530,7 @@ int cmCTestScriptHandler::RunConfigurationScript(
     return result;
   }
 
-  // only run the curent script if we should
+  // only run the current script if we should
   if (this->Makefile && this->Makefile->IsOn("CTEST_RUN_CURRENT_SCRIPT") &&
       this->ShouldRunCurrentScript) {
     return this->RunCurrentScript();
diff --git a/Source/CTest/cmCTestStartCommand.cxx b/Source/CTest/cmCTestStartCommand.cxx
index 38ee62308..3911540f6 100644
--- a/Source/CTest/cmCTestStartCommand.cxx
+++ b/Source/CTest/cmCTestStartCommand.cxx
@@ -28,41 +28,41 @@ bool cmCTestStartCommand::InitialPass(std::vector<std::string> const& args,
   }
 
   size_t cnt = 0;
-  const char* smodel = args[cnt].c_str();
+  const char* smodel = nullptr;
   const char* src_dir = nullptr;
   const char* bld_dir = nullptr;
 
-  cnt++;
-
-  this->CTest->SetSpecificTrack(nullptr);
-  if (cnt < args.size() - 1) {
+  while (cnt < args.size()) {
     if (args[cnt] == "TRACK") {
       cnt++;
+      if (cnt >= args.size() || args[cnt] == "APPEND" ||
+          args[cnt] == "QUIET") {
+        this->SetError("TRACK argument missing track name");
+        return false;
+      }
       this->CTest->SetSpecificTrack(args[cnt].c_str());
       cnt++;
-    }
-  }
-
-  if (cnt < args.size()) {
-    if (args[cnt] == "APPEND") {
+    } else if (args[cnt] == "APPEND") {
       cnt++;
       this->CreateNewTag = false;
-    }
-  }
-  if (cnt < args.size()) {
-    if (args[cnt] == "QUIET") {
+    } else if (args[cnt] == "QUIET") {
       cnt++;
       this->Quiet = true;
-    }
-  }
-
-  if (cnt < args.size()) {
-    src_dir = args[cnt].c_str();
-    cnt++;
-    if (cnt < args.size()) {
+    } else if (!smodel) {
+      smodel = args[cnt].c_str();
+      cnt++;
+    } else if (!src_dir) {
+      src_dir = args[cnt].c_str();
+      cnt++;
+    } else if (!bld_dir) {
       bld_dir = args[cnt].c_str();
+      cnt++;
+    } else {
+      this->SetError("Too many arguments");
+      return false;
     }
   }
+
   if (!src_dir) {
     src_dir = this->Makefile->GetDefinition("CTEST_SOURCE_DIRECTORY");
   }
@@ -79,6 +79,11 @@ bool cmCTestStartCommand::InitialPass(std::vector<std::string> const& args,
                    "as an argument or set CTEST_BINARY_DIRECTORY");
     return false;
   }
+  if (!smodel && this->CreateNewTag) {
+    this->SetError("no test model specified and APPEND not specified. Specify "
+                   "either a test model or the APPEND argument");
+    return false;
+  }
 
   cmSystemTools::AddKeepPath(src_dir);
   cmSystemTools::AddKeepPath(bld_dir);
@@ -92,11 +97,22 @@ bool cmCTestStartCommand::InitialPass(std::vector<std::string> const& args,
   this->CTest->SetCTestConfiguration("BuildDirectory", binaryDir.c_str(),
                                      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);
+  if (smodel) {
+    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);
+  } else {
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                       "Run dashboard with "
+                       "to-be-determined model"
+                         << std::endl
+                         << "   Source directory: " << src_dir << std::endl
+                         << "   Build directory: " << bld_dir << std::endl,
+                       this->Quiet);
+  }
   const char* track = this->CTest->GetSpecificTrack();
   if (track) {
     cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
@@ -128,7 +144,12 @@ bool cmCTestStartCommand::InitialPass(std::vector<std::string> const& args,
 
   this->CTest->SetRunCurrentScript(false);
   this->CTest->SetSuppressUpdatingCTestConfiguration(true);
-  int model = this->CTest->GetTestModelFromString(smodel);
+  int model;
+  if (smodel) {
+    model = this->CTest->GetTestModelFromString(smodel);
+  } else {
+    model = cmCTest::UNKNOWN;
+  }
   this->CTest->SetTestModel(model);
   this->CTest->SetProduceXML(true);
 
diff --git a/Source/CTest/cmCTestSubmitHandler.cxx b/Source/CTest/cmCTestSubmitHandler.cxx
index 08d05c8e8..4c2b75ee3 100644
--- a/Source/CTest/cmCTestSubmitHandler.cxx
+++ b/Source/CTest/cmCTestSubmitHandler.cxx
@@ -7,6 +7,7 @@
 #include "cm_jsoncpp_value.h"
 #include "cmsys/Process.h"
 #include <chrono>
+#include <cstring>
 #include <sstream>
 #include <stdio.h>
 #include <stdlib.h>
@@ -27,9 +28,9 @@
 #include "cmake.h"
 
 #if defined(CTEST_USE_XMLRPC)
-#include "cmVersion.h"
-#include "cm_sys_stat.h"
-#include "cm_xmlrpc.h"
+#  include "cmVersion.h"
+#  include "cm_sys_stat.h"
+#  include "cm_xmlrpc.h"
 #endif
 
 #define SUBMIT_TIMEOUT_IN_SECONDS_DEFAULT 120
@@ -247,14 +248,16 @@ bool cmCTestSubmitHandler::SubmitUsingFTP(const std::string& localprefix,
       res = ::curl_easy_perform(curl);
 
       if (!chunk.empty()) {
-        cmCTestOptionalLog(this->CTest, DEBUG, "CURL output: ["
+        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: ["
+          this->CTest, DEBUG,
+          "CURL debug output: ["
             << cmCTestLogWrite(&*chunkDebug.begin(), chunkDebug.size()) << "]"
             << std::endl,
           this->Quiet);
@@ -262,8 +265,9 @@ bool cmCTestSubmitHandler::SubmitUsingFTP(const std::string& localprefix,
 
       fclose(ftpfile);
       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
@@ -273,7 +277,8 @@ bool cmCTestSubmitHandler::SubmitUsingFTP(const std::string& localprefix,
         // avoid dereference of empty vector
         if (!chunk.empty()) {
           *this->LogFile << cmCTestLogWrite(&*chunk.begin(), chunk.size());
-          cmCTestLog(this->CTest, ERROR_MESSAGE, "CURL output: ["
+          cmCTestLog(this->CTest, ERROR_MESSAGE,
+                     "CURL output: ["
                        << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "]"
                        << std::endl);
         }
@@ -309,7 +314,7 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const std::string& localprefix,
 
   // Add any additional headers that the user specified.
   for (std::string const& h : this->HttpHeaders) {
-    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+    cmCTestOptionalLog(this->CTest, DEBUG,
                        "   Add HTTP Header: \"" << h << "\"" << std::endl,
                        this->Quiet);
     headers = ::curl_slist_append(headers, h.c_str());
@@ -417,8 +422,8 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const std::string& localprefix,
         }
       }
       std::string upload_as = url +
-        ((url.find('?') == std::string::npos) ? '?' : '&') + "FileName=" +
-        ofile;
+        ((url.find('?') == std::string::npos) ? '?' : '&') +
+        "FileName=" + ofile;
 
       upload_as += "&MD5=";
 
@@ -474,7 +479,8 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const std::string& localprefix,
       res = ::curl_easy_perform(curl);
 
       if (!chunk.empty()) {
-        cmCTestOptionalLog(this->CTest, DEBUG, "CURL output: ["
+        cmCTestOptionalLog(this->CTest, DEBUG,
+                           "CURL output: ["
                              << cmCTestLogWrite(&*chunk.begin(), chunk.size())
                              << "]" << std::endl,
                            this->Quiet);
@@ -482,7 +488,8 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const std::string& localprefix,
       }
       if (!chunkDebug.empty()) {
         cmCTestOptionalLog(
-          this->CTest, DEBUG, "CURL debug output: ["
+          this->CTest, DEBUG,
+          "CURL debug output: ["
             << cmCTestLogWrite(&*chunkDebug.begin(), chunkDebug.size()) << "]"
             << std::endl,
           this->Quiet);
@@ -536,7 +543,8 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const std::string& localprefix,
 
           if (!chunk.empty()) {
             cmCTestOptionalLog(
-              this->CTest, DEBUG, "CURL output: ["
+              this->CTest, DEBUG,
+              "CURL output: ["
                 << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "]"
                 << std::endl,
               this->Quiet);
@@ -551,8 +559,9 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const std::string& localprefix,
 
       fclose(ftpfile);
       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
@@ -564,7 +573,8 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const std::string& localprefix,
           *this->LogFile << "   Curl output was: "
                          << cmCTestLogWrite(&*chunk.begin(), chunk.size())
                          << std::endl;
-          cmCTestLog(this->CTest, ERROR_MESSAGE, "CURL output: ["
+          cmCTestLog(this->CTest, ERROR_MESSAGE,
+                     "CURL output: ["
                        << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "]"
                        << std::endl);
         }
@@ -611,7 +621,8 @@ void cmCTestSubmitHandler::ParseResponse(
   }
 
   if (this->HasWarnings || this->HasErrors) {
-    cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Server Response:\n"
+    cmCTestLog(this->CTest, HANDLER_OUTPUT,
+               "   Server Response:\n"
                  << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "\n");
   }
 }
@@ -688,8 +699,8 @@ bool cmCTestSubmitHandler::TriggerUsingHTTP(const std::set<std::string>& files,
         }
       }
       std::string turl = url +
-        ((url.find('?') == std::string::npos) ? '?' : '&') + "xmlfile=" +
-        ofile;
+        ((url.find('?') == 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);
@@ -708,7 +719,8 @@ bool cmCTestSubmitHandler::TriggerUsingHTTP(const std::set<std::string>& files,
           *this->LogFile << "   Curl output was: "
                          << cmCTestLogWrite(&*chunk.begin(), chunk.size())
                          << std::endl;
-          cmCTestLog(this->CTest, ERROR_MESSAGE, "CURL output: ["
+          cmCTestLog(this->CTest, ERROR_MESSAGE,
+                     "CURL output: ["
                        << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "]"
                        << std::endl);
         }
@@ -718,14 +730,16 @@ bool cmCTestSubmitHandler::TriggerUsingHTTP(const std::set<std::string>& files,
       }
 
       if (!chunk.empty()) {
-        cmCTestOptionalLog(this->CTest, DEBUG, "CURL output: ["
+        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: ["
+          this->CTest, DEBUG,
+          "CURL debug output: ["
             << cmCTestLogWrite(&*chunkDebug.begin(), chunkDebug.size()) << "]"
             << std::endl,
           this->Quiet);
@@ -776,9 +790,9 @@ bool cmCTestSubmitHandler::SubmitUsingSCP(const std::string& scp_command,
     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,
+    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;
@@ -823,13 +837,14 @@ bool cmCTestSubmitHandler::SubmitUsingSCP(const std::string& scp_command,
       *this->LogFile << "\tThere was an exception: " << retVal << std::endl;
       problems++;
     } else if (result == cmsysProcess_State_Expired) {
-      cmCTestLog(this->CTest, ERROR_MESSAGE, "\tThere was a timeout"
-                   << std::endl);
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "\tThere was a timeout" << std::endl);
       *this->LogFile << "\tThere was a timeout" << std::endl;
       problems++;
     } else if (result == cmsysProcess_State_Error) {
-      cmCTestLog(this->CTest, ERROR_MESSAGE, "\tError executing SCP: "
-                   << cmsysProcess_GetErrorString(cp) << std::endl);
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "\tError executing SCP: " << cmsysProcess_GetErrorString(cp)
+                                           << std::endl);
       *this->LogFile << "\tError executing SCP: "
                      << cmsysProcess_GetErrorString(cp) << std::endl;
       problems++;
@@ -863,8 +878,9 @@ bool cmCTestSubmitHandler::SubmitUsingCP(const std::string& localprefix,
     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,
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       "   Copy file: " << lfname << " to " << rfname
+                                        << std::endl,
                        this->Quiet);
   }
   std::string tagDoneFile = destination + "/" + remoteprefix + "DONE";
@@ -891,8 +907,9 @@ bool cmCTestSubmitHandler::SubmitUsingXMLRPC(
   xmlrpc_env_init(&env);
 
   /* Call the famous server at UserLand. */
-  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "   Submitting to: "
-                       << realURL << " (" << remoteprefix << ")" << std::endl,
+  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                     "   Submitting to: " << realURL << " (" << remoteprefix
+                                          << ")" << std::endl,
                      this->Quiet);
   for (std::string const& file : files) {
     xmlrpc_value* result;
@@ -915,8 +932,8 @@ bool cmCTestSubmitHandler::SubmitUsingXMLRPC(
     // 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
-                                                                << std::endl);
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "  File too big: " << local_file << std::endl);
       return false;
     }
     size_t fileSize = static_cast<size_t>(st.st_size);
@@ -946,9 +963,10 @@ bool cmCTestSubmitHandler::SubmitUsingXMLRPC(
     delete[] fileBuffer;
 
     if (env.fault_occurred) {
-      cmCTestLog(this->CTest, ERROR_MESSAGE, " Submission problem: "
-                   << env.fault_string << " (" << env.fault_code << ")"
-                   << std::endl);
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 " Submission problem: " << env.fault_string << " ("
+                                         << env.fault_code << ")"
+                                         << std::endl);
       xmlrpc_env_clean(&env);
       xmlrpc_client_cleanup();
       return false;
@@ -1003,8 +1021,8 @@ int cmCTestSubmitHandler::HandleCDashUploadFile(std::string const& file,
     return -1;
   }
   if (!cmSystemTools::FileExists(file)) {
-    cmCTestLog(this->CTest, ERROR_MESSAGE, "Upload file not found: '"
-                 << file << "'\n");
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Upload file not found: '" << file << "'\n");
     return -1;
   }
   cmCTestCurl curl(this->CTest);
@@ -1039,8 +1057,9 @@ int cmCTestSubmitHandler::HandleCDashUploadFile(std::string const& file,
     unsigned long retryDelayValue = 0;
     if (!cmSystemTools::StringToULong(retryDelayString.c_str(),
                                       &retryDelayValue)) {
-      cmCTestLog(this->CTest, WARNING, "Invalid value for 'RETRY_DELAY' : "
-                   << retryDelayString << std::endl);
+      cmCTestLog(this->CTest, WARNING,
+                 "Invalid value for 'RETRY_DELAY' : " << retryDelayString
+                                                      << std::endl);
     } else {
       retryDelay = std::chrono::seconds(retryDelayValue);
     }
@@ -1048,8 +1067,9 @@ int cmCTestSubmitHandler::HandleCDashUploadFile(std::string const& file,
   unsigned long retryCount = 0;
   if (!retryCountString.empty()) {
     if (!cmSystemTools::StringToULong(retryCountString.c_str(), &retryCount)) {
-      cmCTestLog(this->CTest, WARNING, "Invalid value for 'RETRY_DELAY' : "
-                   << retryCountString << std::endl);
+      cmCTestLog(this->CTest, WARNING,
+                 "Invalid value for 'RETRY_DELAY' : " << retryCountString
+                                                      << std::endl);
     }
   }
 
@@ -1117,7 +1137,8 @@ int cmCTestSubmitHandler::HandleCDashUploadFile(std::string const& file,
     }
   }
   if (!internalTest && !requestSucceeded) {
-    cmCTestLog(this->CTest, ERROR_MESSAGE, "Error in HttpRequest\n"
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Error in HttpRequest\n"
                  << response);
     return -1;
   }
@@ -1127,7 +1148,8 @@ int cmCTestSubmitHandler::HandleCDashUploadFile(std::string const& file,
   Json::Value json;
   Json::Reader reader;
   if (!internalTest && !reader.parse(response, json)) {
-    cmCTestLog(this->CTest, ERROR_MESSAGE, "error parsing json string ["
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "error parsing json string ["
                  << response << "]\n"
                  << reader.getFormattedErrorMessages() << "\n");
     return -1;
@@ -1194,12 +1216,14 @@ int cmCTestSubmitHandler::HandleCDashUploadFile(std::string const& file,
   }
 
   if (!uploadSucceeded) {
-    cmCTestLog(this->CTest, ERROR_MESSAGE, "error uploading to CDash. "
-                 << file << " " << url << " " << fstr.str());
+    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 ["
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "error parsing json string ["
                  << response << "]\n"
                  << reader.getFormattedErrorMessages() << "\n");
     return -1;
@@ -1356,7 +1380,8 @@ int cmCTestSubmitHandler::ProcessHandler()
       cnt++;
     }
   }
-  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "Submit files (using "
+  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                     "Submit files (using "
                        << this->CTest->GetCTestConfiguration("DropMethod")
                        << ")" << std::endl,
                      this->Quiet);
@@ -1379,8 +1404,9 @@ int cmCTestSubmitHandler::ProcessHandler()
     std::string url = "ftp://";
     url += cmCTest::MakeURLSafe(
              this->CTest->GetCTestConfiguration("DropSiteUser")) +
-      ":" + cmCTest::MakeURLSafe(
-              this->CTest->GetCTestConfiguration("DropSitePassword")) +
+      ":" +
+      cmCTest::MakeURLSafe(
+             this->CTest->GetCTestConfiguration("DropSitePassword")) +
       "@" + this->CTest->GetCTestConfiguration("DropSite") +
       cmCTest::MakeURLSafe(this->CTest->GetCTestConfiguration("DropLocation"));
     if (!this->CTest->GetCTestConfiguration("DropSiteUser").empty()) {
@@ -1408,12 +1434,13 @@ int cmCTestSubmitHandler::ProcessHandler()
       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);
+      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"))) {
@@ -1465,12 +1492,13 @@ int cmCTestSubmitHandler::ProcessHandler()
       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);
+      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"))) {
@@ -1481,15 +1509,17 @@ int cmCTestSubmitHandler::ProcessHandler()
       }
     }
     if (this->HasErrors) {
-      cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Errors occurred during "
-                                              "submission."
+      cmCTestLog(this->CTest, HANDLER_OUTPUT,
+                 "   Errors occurred during "
+                 "submission."
                    << std::endl);
       ofs << "   Errors occurred during submission. " << std::endl;
     } else {
-      cmCTestOptionalLog(
-        this->CTest, HANDLER_OUTPUT, "   Submission successful"
-          << (this->HasWarnings ? ", with warnings." : "") << std::endl,
-        this->Quiet);
+      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                         "   Submission successful"
+                           << (this->HasWarnings ? ", with warnings." : "")
+                           << std::endl,
+                         this->Quiet);
       ofs << "   Submission successful"
           << (this->HasWarnings ? ", with warnings." : "") << std::endl;
     }
@@ -1532,6 +1562,15 @@ int cmCTestSubmitHandler::ProcessHandler()
     // change to the build directory so that we can uses a relative path
     // on windows since scp doesn't support "c:" a drive in the path
     cmWorkingDirectory workdir(buildDirectory);
+    if (workdir.Failed()) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "   Failed to change directory to "
+                   << buildDirectory << " : "
+                   << std::strerror(workdir.GetLastResult()) << std::endl);
+      ofs << "   Failed to change directory to " << buildDirectory << " : "
+          << std::strerror(workdir.GetLastResult()) << std::endl;
+      return -1;
+    }
 
     if (!this->SubmitUsingSCP(this->CTest->GetCTestConfiguration("ScpCommand"),
                               "Testing/" + this->CTest->GetCurrentTag(), files,
@@ -1551,6 +1590,15 @@ int cmCTestSubmitHandler::ProcessHandler()
     // change to the build directory so that we can uses a relative path
     // on windows since scp doesn't support "c:" a drive in the path
     cmWorkingDirectory workdir(buildDirectory);
+    if (workdir.Failed()) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "   Failed to change directory to "
+                   << buildDirectory << " : "
+                   << std::strerror(workdir.GetLastResult()) << std::endl);
+      ofs << "   Failed to change directory to " << buildDirectory << " : "
+          << std::strerror(workdir.GetLastResult()) << std::endl;
+      return -1;
+    }
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
                        "   Change directory: " << buildDirectory << std::endl,
                        this->Quiet);
@@ -1568,8 +1616,9 @@ int cmCTestSubmitHandler::ProcessHandler()
     return 0;
   }
 
-  cmCTestLog(this->CTest, ERROR_MESSAGE, "   Unknown submission method: \""
-               << dropMethod << "\"" << std::endl);
+  cmCTestLog(this->CTest, ERROR_MESSAGE,
+             "   Unknown submission method: \"" << dropMethod << "\""
+                                                << std::endl);
   return -1;
 }
 
diff --git a/Source/CTest/cmCTestTestCommand.cxx b/Source/CTest/cmCTestTestCommand.cxx
index daedf6255..895ca1267 100644
--- a/Source/CTest/cmCTestTestCommand.cxx
+++ b/Source/CTest/cmCTestTestCommand.cxx
@@ -112,14 +112,16 @@ cmCTestGenericHandler* cmCTestTestCommand::InitializeHandler()
     if (!cmSystemTools::StringToULong(this->Values[ctt_TEST_LOAD],
                                       &testLoad)) {
       testLoad = 0;
-      cmCTestLog(this->CTest, WARNING, "Invalid value for 'TEST_LOAD' : "
+      cmCTestLog(this->CTest, WARNING,
+                 "Invalid value for 'TEST_LOAD' : "
                    << this->Values[ctt_TEST_LOAD] << std::endl);
     }
   } 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 {
     testLoad = this->CTest->GetTestLoad();
diff --git a/Source/CTest/cmCTestTestHandler.cxx b/Source/CTest/cmCTestTestHandler.cxx
index 84d8926ea..91b92a37d 100644
--- a/Source/CTest/cmCTestTestHandler.cxx
+++ b/Source/CTest/cmCTestTestHandler.cxx
@@ -6,6 +6,7 @@
 #include <cmsys/Base64.h>
 #include <cmsys/Directory.hxx>
 #include <cmsys/RegularExpression.hxx>
+#include <cstring>
 #include <functional>
 #include <iomanip>
 #include <iterator>
@@ -14,7 +15,6 @@
 #include <sstream>
 #include <stdio.h>
 #include <stdlib.h>
-#include <string.h>
 #include <time.h>
 
 #include "cmAlgorithms.h"
@@ -85,6 +85,11 @@ bool cmCTestSubdirCommand::InitialPass(std::vector<std::string> const& args,
     bool readit = false;
     {
       cmWorkingDirectory workdir(fname);
+      if (workdir.Failed()) {
+        this->SetError("Failed to change directory to " + fname + " : " +
+                       std::strerror(workdir.GetLastResult()));
+        return false;
+      }
       const char* testFilename;
       if (cmSystemTools::FileExists("CTestTestfile.cmake")) {
         // does the CTestTestfile.cmake exist ?
@@ -254,7 +259,7 @@ public:
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
-  */
+   */
   bool InitialPass(std::vector<std::string> const& /*unused*/,
                    cmExecutionStatus& /*unused*/) override;
 
@@ -467,11 +472,12 @@ int cmCTestTestHandler::ProcessHandler()
 
   this->TestResults.clear();
 
-  cmCTestOptionalLog(
-    this->CTest, HANDLER_OUTPUT, (this->MemCheck ? "Memory check" : "Test")
-      << " project " << cmSystemTools::GetCurrentWorkingDirectory()
-      << std::endl,
-    this->Quiet);
+  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                     (this->MemCheck ? "Memory check" : "Test")
+                       << " project "
+                       << cmSystemTools::GetCurrentWorkingDirectory()
+                       << std::endl,
+                     this->Quiet);
   if (!this->PreProcessHandler()) {
     return -1;
   }
@@ -495,13 +501,14 @@ int cmCTestTestHandler::ProcessHandler()
 
   if (total == 0) {
     if (!this->CTest->GetShowOnly() && !this->CTest->ShouldPrintLabels()) {
-      cmCTestLog(this->CTest, ERROR_MESSAGE, "No tests were found!!!"
-                   << std::endl);
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "No tests were found!!!" << std::endl);
     }
   } else {
     if (this->HandlerVerbose && !passed.empty() &&
         (this->UseIncludeRegExpFlag || this->UseExcludeRegExpFlag)) {
-      cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, std::endl
+      cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                         std::endl
                            << "The following tests passed:" << std::endl,
                          this->Quiet);
       for (std::string const& j : passed) {
@@ -528,7 +535,8 @@ int cmCTestTestHandler::ProcessHandler()
       percent = 99;
     }
 
-    cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl
+    cmCTestLog(this->CTest, HANDLER_OUTPUT,
+               std::endl
                  << static_cast<int>(percent + .5f) << "% tests passed, "
                  << failed.size() << " tests failed out of " << total
                  << std::endl);
@@ -548,7 +556,8 @@ int cmCTestTestHandler::ProcessHandler()
 
     if (!disabledTests.empty()) {
       cmGeneratedFileStream ofs;
-      cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl
+      cmCTestLog(this->CTest, HANDLER_OUTPUT,
+                 std::endl
                    << "The following tests did not run:" << std::endl);
       this->StartLogFile("TestsDisabled", ofs);
 
@@ -560,15 +569,16 @@ int cmCTestTestHandler::ProcessHandler()
         } else {
           disabled_reason = "Skipped";
         }
-        cmCTestLog(this->CTest, HANDLER_OUTPUT, "\t"
-                     << std::setw(3) << dt.TestCount << " - " << dt.Name
-                     << " (" << disabled_reason << ")" << std::endl);
+        cmCTestLog(this->CTest, HANDLER_OUTPUT,
+                   "\t" << std::setw(3) << dt.TestCount << " - " << dt.Name
+                        << " (" << disabled_reason << ")" << std::endl);
       }
     }
 
     if (!failed.empty()) {
       cmGeneratedFileStream ofs;
-      cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl
+      cmCTestLog(this->CTest, HANDLER_OUTPUT,
+                 std::endl
                    << "The following tests FAILED:" << std::endl);
       this->StartLogFile("TestsFailed", ofs);
 
@@ -577,9 +587,10 @@ int cmCTestTestHandler::ProcessHandler()
             !cmHasLiteralPrefix(ft.CompletionStatus, "SKIP_RETURN_CODE=") &&
             ft.CompletionStatus != "Disabled") {
           ofs << ft.TestCount << ":" << ft.Name << std::endl;
-          cmCTestLog(this->CTest, HANDLER_OUTPUT, "\t"
-                       << std::setw(3) << ft.TestCount << " - " << ft.Name
-                       << " (" << this->GetTestStatus(ft) << ")" << std::endl);
+          cmCTestLog(this->CTest, HANDLER_OUTPUT,
+                     "\t" << std::setw(3) << ft.TestCount << " - " << ft.Name
+                          << " (" << this->GetTestStatus(ft) << ")"
+                          << std::endl);
         }
       }
     }
@@ -590,7 +601,8 @@ int cmCTestTestHandler::ProcessHandler()
     if (!this->StartResultingXML(
           (this->MemCheck ? cmCTest::PartMemCheck : cmCTest::PartTest),
           (this->MemCheck ? "DynamicAnalysis" : "Test"), xmlfile)) {
-      cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot create "
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "Cannot create "
                    << (this->MemCheck ? "memory check" : "testing")
                    << " XML file" << std::endl);
       this->LogFile = nullptr;
@@ -666,8 +678,8 @@ void cmCTestTestHandler::PrintLabelOrSubprojectSummary(bool doSubProject)
     cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
                        "\nSubproject Time Summary:", this->Quiet);
   } else {
-    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "\nLabel Time Summary:",
-                       this->Quiet);
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                       "\nLabel Time Summary:", this->Quiet);
   }
   for (std::string const& i : labels) {
     std::string label = i;
@@ -682,7 +694,8 @@ void cmCTestTestHandler::PrintLabelOrSubprojectSummary(bool doSubProject)
       labelCountStr << "s";
     }
     labelCountStr << ")";
-    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "\n"
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                       "\n"
                          << label << " = " << buf << " "
                          << labelCountStr.str(),
                        this->Quiet);
@@ -1084,9 +1097,10 @@ void cmCTestTestHandler::UpdateForFixtures(ListOfTests& tests) const
     }
   }
 
-  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Added "
-                       << fixtureTestsAdded
-                       << " tests to meet fixture requirements" << std::endl,
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     "Added " << fixtureTestsAdded
+                              << " tests to meet fixture requirements"
+                              << std::endl,
                      this->Quiet);
 }
 
@@ -1114,8 +1128,9 @@ bool cmCTestTestHandler::GetValue(const char* tag, int& value,
     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);
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "parse error: missing tag: " << tag << " found [" << line << "]"
+                                            << std::endl);
     ret = false;
   }
   return ret;
@@ -1131,8 +1146,9 @@ bool cmCTestTestHandler::GetValue(const char* tag, double& value,
     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);
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "parse error: missing tag: " << tag << " found [" << line << "]"
+                                            << std::endl);
     ret = false;
   }
   return ret;
@@ -1157,8 +1173,9 @@ bool cmCTestTestHandler::GetValue(const char* tag, bool& 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);
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "parse error: missing tag: " << tag << " found [" << line << "]"
+                                            << std::endl);
     ret = false;
   }
   return ret;
@@ -1174,8 +1191,9 @@ bool cmCTestTestHandler::GetValue(const char* tag, size_t& value,
     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);
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "parse error: missing tag: " << tag << " found [" << line << "]"
+                                            << std::endl);
     ret = false;
   }
   return ret;
@@ -1190,8 +1208,9 @@ bool cmCTestTestHandler::GetValue(const char* tag, std::string& value,
   if (line == tag) {
     ret = cmSystemTools::GetLineFromStream(fin, value);
   } else {
-    cmCTestLog(this->CTest, ERROR_MESSAGE, "parse error: missing tag: "
-                 << tag << " found [" << line << "]" << std::endl);
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "parse error: missing tag: " << tag << " found [" << line << "]"
+                                            << std::endl);
     ret = false;
   }
   return ret;
@@ -1606,7 +1625,8 @@ std::string cmCTestTestHandler::FindExecutable(
     }
   }
   if (fullPath.empty()) {
-    cmCTestLog(ctest, HANDLER_OUTPUT, "Could not find executable "
+    cmCTestLog(ctest, HANDLER_OUTPUT,
+               "Could not find executable "
                  << testCommand << "\n"
                  << "Looked in the following places:\n");
     for (std::string const& f : failed) {
@@ -1788,8 +1808,8 @@ void cmCTestTestHandler::ExpandTestsToRunInformationForRerunFailed()
 
   cmsys::Directory directory;
   if (directory.Load(dirName) == 0) {
-    cmCTestLog(this->CTest, ERROR_MESSAGE, "Unable to read the contents of "
-                 << dirName << std::endl);
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Unable to read the contents of " << dirName << std::endl);
     return;
   }
 
@@ -1824,8 +1844,8 @@ void cmCTestTestHandler::ExpandTestsToRunInformationForRerunFailed()
 
   if (!cmSystemTools::FileExists(lastTestsFailedLog)) {
     if (!this->CTest->GetShowOnly() && !this->CTest->ShouldPrintLabels()) {
-      cmCTestLog(this->CTest, ERROR_MESSAGE, lastTestsFailedLog
-                   << " does not exist!" << std::endl);
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 lastTestsFailedLog << " does not exist!" << std::endl);
     }
     return;
   }
@@ -1847,7 +1867,8 @@ void cmCTestTestHandler::ExpandTestsToRunInformationForRerunFailed()
     ifs.close();
   } else if (!this->CTest->GetShowOnly() &&
              !this->CTest->ShouldPrintLabels()) {
-    cmCTestLog(this->CTest, ERROR_MESSAGE, "Problem reading file: "
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Problem reading file: "
                  << lastTestsFailedLog
                  << " while generating list of previously failed tests."
                  << std::endl);
@@ -1956,11 +1977,12 @@ void cmCTestTestHandler::GenerateRegressionImages(cmXMLWriter& xml,
           xml.Element("Value", "Image " + filename + " is empty");
           xml.EndElement();
         } else {
-          cmsys::ifstream ifs(filename.c_str(), std::ios::in
+          cmsys::ifstream ifs(filename.c_str(),
+                              std::ios::in
 #ifdef _WIN32
                                 | std::ios::binary
 #endif
-                              );
+          );
           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>(
@@ -1997,9 +2019,9 @@ void cmCTestTestHandler::GenerateRegressionImages(cmXMLWriter& xml,
         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);
+        cmCTestOptionalLog(
+          this->CTest, HANDLER_OUTPUT,
+          "File \"" << filename << "\" not found." << std::endl, this->Quiet);
       }
       cxml.erase(measurementfile.start(),
                  measurementfile.end() - measurementfile.start());
@@ -2165,6 +2187,9 @@ bool cmCTestTestHandler::SetTestsProperties(
               rt.Processors = 1;
             }
           }
+          if (key == "PROCESSOR_AFFINITY") {
+            rt.WantAffinity = cmSystemTools::IsOn(val.c_str());
+          }
           if (key == "SKIP_RETURN_CODE") {
             rt.SkipReturnCode = atoi(val.c_str());
             if (rt.SkipReturnCode < 0 || rt.SkipReturnCode > 255) {
@@ -2336,6 +2361,7 @@ bool cmCTestTestHandler::AddTest(const std::vector<std::string>& args)
   test.ExplicitTimeout = false;
   test.Cost = 0;
   test.Processors = 1;
+  test.WantAffinity = false;
   test.SkipReturnCode = -1;
   test.PreviousRuns = 0;
   if (this->UseIncludeRegExpFlag &&
diff --git a/Source/CTest/cmCTestTestHandler.h b/Source/CTest/cmCTestTestHandler.h
index f4978b677..d2694a114 100644
--- a/Source/CTest/cmCTestTestHandler.h
+++ b/Source/CTest/cmCTestTestHandler.h
@@ -130,6 +130,8 @@ public:
     int Index;
     // Requested number of process slots
     int Processors;
+    bool WantAffinity;
+    std::vector<size_t> Affinity;
     // return code of test which will mark test as "not run"
     int SkipReturnCode;
     std::vector<std::string> Environment;
diff --git a/Source/CTest/cmCTestUpdateHandler.cxx b/Source/CTest/cmCTestUpdateHandler.cxx
index 504b2102a..57e40ce35 100644
--- a/Source/CTest/cmCTestUpdateHandler.cxx
+++ b/Source/CTest/cmCTestUpdateHandler.cxx
@@ -47,7 +47,8 @@ void cmCTestUpdateHandler::Initialize()
 
 int cmCTestUpdateHandler::DetermineType(const char* cmd, const char* type)
 {
-  cmCTestOptionalLog(this->CTest, DEBUG, "Determine update type from command: "
+  cmCTestOptionalLog(this->CTest, DEBUG,
+                     "Determine update type from command: "
                        << cmd << " and type: " << type << std::endl,
                      this->Quiet);
   if (type && *type) {
@@ -130,7 +131,8 @@ int cmCTestUpdateHandler::ProcessHandler()
     return -1;
   }
 
-  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "   Use "
+  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                     "   Use "
                        << cmCTestUpdateHandlerUpdateToString(this->UpdateType)
                        << " repository type" << std::endl;
                      , this->Quiet);
@@ -171,8 +173,8 @@ int cmCTestUpdateHandler::ProcessHandler()
   //
   cmGeneratedFileStream os;
   if (!this->StartResultingXML(cmCTest::PartUpdate, "Update", os)) {
-    cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot open log file"
-                 << std::endl);
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Cannot open log file" << std::endl);
     return -1;
   }
   std::string start_time = this->CTest->CurrentTime();
@@ -191,7 +193,8 @@ int cmCTestUpdateHandler::ProcessHandler()
                 std::string("ctest-") + cmVersion::GetCMakeVersion());
   xml.Element("Site", this->CTest->GetCTestConfiguration("Site"));
   xml.Element("BuildName", buildname);
-  xml.Element("BuildStamp", this->CTest->GetCurrentTag() + "-" +
+  xml.Element("BuildStamp",
+              this->CTest->GetCurrentTag() + "-" +
                 this->CTest->GetTestModelString());
   xml.Element("StartDateTime", start_time);
   xml.Element("StartTime", start_time_time);
@@ -209,9 +212,9 @@ int cmCTestUpdateHandler::ProcessHandler()
                        this->Quiet);
   }
   if (int numModified = vc->GetPathCount(cmCTestVC::PathModified)) {
-    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "   Found "
-                         << numModified << " locally modified files\n",
-                       this->Quiet);
+    cmCTestOptionalLog(
+      this->CTest, HANDLER_OUTPUT,
+      "   Found " << numModified << " locally modified files\n", this->Quiet);
     localModifications += numModified;
   }
   if (int numConflicting = vc->GetPathCount(cmCTestVC::PathConflicting)) {
@@ -241,8 +244,9 @@ int cmCTestUpdateHandler::ProcessHandler()
   if (!updated) {
     xml.Content("Update command failed:\n");
     xml.Content(vc->GetUpdateCommandLine());
-    cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Update command failed: "
-                 << vc->GetUpdateCommandLine() << "\n");
+    cmCTestLog(this->CTest, HANDLER_OUTPUT,
+               "   Update command failed: " << vc->GetUpdateCommandLine()
+                                            << "\n");
   }
   xml.EndElement(); // UpdateReturnStatus
   xml.EndElement(); // Update
diff --git a/Source/CTest/cmCTestUploadHandler.cxx b/Source/CTest/cmCTestUploadHandler.cxx
index 59a5de484..261ecab9a 100644
--- a/Source/CTest/cmCTestUploadHandler.cxx
+++ b/Source/CTest/cmCTestUploadHandler.cxx
@@ -30,8 +30,8 @@ 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);
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Cannot open Upload.xml file" << std::endl);
     return -1;
   }
   std::string buildname =
@@ -45,7 +45,8 @@ int cmCTestUploadHandler::ProcessHandler()
                             "<file:///Dart/Source/Server/XSL/Build.xsl> \"");
   xml.StartElement("Site");
   xml.Attribute("BuildName", buildname);
-  xml.Attribute("BuildStamp", this->CTest->GetCurrentTag() + "-" +
+  xml.Attribute("BuildStamp",
+                this->CTest->GetCurrentTag() + "-" +
                   this->CTest->GetTestModelString());
   xml.Attribute("Name", this->CTest->GetCTestConfiguration("Site"));
   xml.Attribute("Generator",
diff --git a/Source/CTest/cmCTestVC.cxx b/Source/CTest/cmCTestVC.cxx
index 13fa6e1f5..a59d671dd 100644
--- a/Source/CTest/cmCTestVC.cxx
+++ b/Source/CTest/cmCTestVC.cxx
@@ -69,8 +69,8 @@ bool cmCTestVC::InitialCheckout(const char* command)
   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);
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Initial checkout failed!" << std::endl);
   }
   return result;
 }
diff --git a/Source/CTest/cmParseCacheCoverage.cxx b/Source/CTest/cmParseCacheCoverage.cxx
index 4cd6588be..ca1fe70e4 100644
--- a/Source/CTest/cmParseCacheCoverage.cxx
+++ b/Source/CTest/cmParseCacheCoverage.cxx
@@ -100,10 +100,11 @@ bool cmParseCacheCoverage::ReadCMCovFile(const char* file)
   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");
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Empty file : " << file
+                               << "  referenced in this line of cmcov data:\n"
+                                  "["
+                               << line << "]\n");
     return false;
   }
   separateLine.clear();
@@ -112,8 +113,9 @@ bool cmParseCacheCoverage::ReadCMCovFile(const char* file)
       separateLine[1] != "Line" || separateLine[2] != "RtnLine" ||
       separateLine[3] != "Code") {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
-               "Bad first line of cmcov file : " << file << "  line:\n"
-                                                            "["
+               "Bad first line of cmcov file : " << file
+                                                 << "  line:\n"
+                                                    "["
                                                  << line << "]\n");
   }
   std::string routine;
@@ -128,8 +130,9 @@ bool cmParseCacheCoverage::ReadCMCovFile(const char* file)
     if (separateLine.size() < 4) {
       cmCTestLog(this->CTest, ERROR_MESSAGE,
                  "Bad line of cmcov file expected at least 4 found: "
-                   << separateLine.size() << " " << file << "  line:\n"
-                                                            "["
+                   << 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] << " ");
diff --git a/Source/CTest/cmParseDelphiCoverage.cxx b/Source/CTest/cmParseDelphiCoverage.cxx
index 6d82cb2e7..cc8197951 100644
--- a/Source/CTest/cmParseDelphiCoverage.cxx
+++ b/Source/CTest/cmParseDelphiCoverage.cxx
@@ -108,8 +108,9 @@ public:
     while (true) {
       lastoffset = line.find('(', pos);
       if (lastoffset == std::string::npos) {
-        cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, endnamepos
-                             << "File not found  " << lastoffset << std::endl,
+        cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                           endnamepos << "File not found  " << lastoffset
+                                      << std::endl,
                            this->Coverage.Quiet);
         return false;
       }
diff --git a/Source/CTest/cmParseGTMCoverage.cxx b/Source/CTest/cmParseGTMCoverage.cxx
index f965048bb..822363d2d 100644
--- a/Source/CTest/cmParseGTMCoverage.cxx
+++ b/Source/CTest/cmParseGTMCoverage.cxx
@@ -75,7 +75,8 @@ bool cmParseGTMCoverage::ReadMCovFile(const char* file)
         this->Coverage.TotalCoverage[lastpath][lastoffset + linenumber] +=
           count;
       } else {
-        cmCTestLog(this->CTest, ERROR_MESSAGE, "Can not find mumps file : "
+        cmCTestLog(this->CTest, ERROR_MESSAGE,
+                   "Can not find mumps file : "
                      << lastroutine
                      << "  referenced in this line of mcov data:\n"
                         "["
@@ -102,9 +103,11 @@ bool cmParseGTMCoverage::ReadMCovFile(const char* file)
         lastoffset = lineoffset;
       }
     } else {
-      cmCTestLog(this->CTest, ERROR_MESSAGE, "Can not find mumps file : "
-                   << routine << "  referenced in this line of mcov data:\n"
-                                 "["
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "Can not find mumps file : "
+                   << routine
+                   << "  referenced in this line of mcov data:\n"
+                      "["
                    << line << "]\n");
     }
     lastfunction = function;
@@ -144,8 +147,9 @@ bool cmParseGTMCoverage::FindFunctionInMumpsFile(std::string const& filepath,
     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;
 }
 
@@ -221,8 +225,8 @@ bool cmParseGTMCoverage::ParseMCOVLine(std::string const& line,
   }
   // less then two arguments is an error
   if (args.size() < 2) {
-    cmCTestLog(this->CTest, ERROR_MESSAGE, "Error parsing mcov line: ["
-                 << line << "]\n");
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Error parsing mcov line: [" << line << "]\n");
     return false;
   }
   routine = args[0];  // the routine is the first argument
diff --git a/Source/CTest/cmParseJacocoCoverage.cxx b/Source/CTest/cmParseJacocoCoverage.cxx
index 7acb5ca3f..31e7cd4d4 100644
--- a/Source/CTest/cmParseJacocoCoverage.cxx
+++ b/Source/CTest/cmParseJacocoCoverage.cxx
@@ -38,8 +38,9 @@ protected:
 
       if (this->PackagePath.empty()) {
         if (!this->FindPackagePath(fileName)) {
-          cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot find file: "
-                       << this->PackageName << "/" << fileName << std::endl);
+          cmCTestLog(this->CTest, ERROR_MESSAGE,
+                     "Cannot find file: " << this->PackageName << "/"
+                                          << fileName << std::endl);
           this->Coverage.Error++;
           return;
         }
diff --git a/Source/CTest/cmParsePHPCoverage.cxx b/Source/CTest/cmParsePHPCoverage.cxx
index 761ebec65..a6e65c9df 100644
--- a/Source/CTest/cmParsePHPCoverage.cxx
+++ b/Source/CTest/cmParsePHPCoverage.cxx
@@ -153,7 +153,8 @@ bool cmParsePHPCoverage::ReadFileInformation(std::istream& in)
     delete[] s;
     // read close quote
     if (in.get(c) && c != '"') {
-      cmCTestLog(this->CTest, ERROR_MESSAGE, "failed to read close quote\n"
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "failed to read close quote\n"
                    << "read [" << c << "]\n");
       return false;
     }
@@ -184,8 +185,8 @@ bool cmParsePHPCoverage::ReadPHPData(const char* file)
   }
   for (int i = 0; i < size; i++) {
     if (!this->ReadFileInformation(in)) {
-      cmCTestLog(this->CTest, ERROR_MESSAGE, "Failed to read file #" << i
-                                                                     << "\n");
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "Failed to read file #" << i << "\n");
       return false;
     }
     in.get(c);
diff --git a/Source/CTest/cmProcess.cxx b/Source/CTest/cmProcess.cxx
index 09ed0a914..39cea8795 100644
--- a/Source/CTest/cmProcess.cxx
+++ b/Source/CTest/cmProcess.cxx
@@ -13,13 +13,13 @@
 #include <signal.h>
 #include <string>
 #if !defined(_WIN32)
-#include <unistd.h>
+#  include <unistd.h>
 #endif
 
 #define CM_PROCESS_BUF_SIZE 65536
 
 #if defined(_WIN32) && !defined(__CYGWIN__)
-#include <io.h>
+#  include <io.h>
 
 static int cmProcessGetPipes(int* fds)
 {
@@ -40,7 +40,7 @@ static int cmProcessGetPipes(int* fds)
   return 0;
 }
 #else
-#include <errno.h>
+#  include <errno.h>
 
 static int cmProcessGetPipes(int* fds)
 {
@@ -83,7 +83,7 @@ void cmProcess::SetCommandArguments(std::vector<std::string> const& args)
   this->Arguments = args;
 }
 
-bool cmProcess::StartProcess(uv_loop_t& loop)
+bool cmProcess::StartProcess(uv_loop_t& loop, std::vector<size_t>* affinity)
 {
   this->ProcessState = cmProcess::State::Error;
   if (this->Command.empty()) {
@@ -138,6 +138,22 @@ bool cmProcess::StartProcess(uv_loop_t& loop)
   options.stdio_count = 3; // in, out and err
   options.exit_cb = &cmProcess::OnExitCB;
   options.stdio = stdio;
+#if !defined(CMAKE_USE_SYSTEM_LIBUV)
+  std::vector<char> cpumask;
+  if (affinity && !affinity->empty()) {
+    cpumask.resize(static_cast<size_t>(uv_cpumask_size()), 0);
+    for (auto p : *affinity) {
+      cpumask[p] = 1;
+    }
+    options.cpumask = cpumask.data();
+    options.cpumask_size = cpumask.size();
+  } else {
+    options.cpumask = nullptr;
+    options.cpumask_size = 0;
+  }
+#else
+  static_cast<void>(affinity);
+#endif
 
   status =
     uv_read_start(pipe_reader, &cmProcess::OnAllocateCB, &cmProcess::OnReadCB);
@@ -151,8 +167,9 @@ bool cmProcess::StartProcess(uv_loop_t& loop)
 
   status = this->Process.spawn(loop, options, this);
   if (status != 0) {
-    cmCTestLog(this->Runner.GetCTest(), ERROR_MESSAGE, "Process not started\n "
-                 << this->Command << "\n[" << uv_strerror(status) << "]\n");
+    cmCTestLog(this->Runner.GetCTest(), ERROR_MESSAGE,
+               "Process not started\n " << this->Command << "\n["
+                                        << uv_strerror(status) << "]\n");
     return false;
   }
 
@@ -329,7 +346,7 @@ void cmProcess::OnExit(int64_t exit_status, int term_signal)
 #else
       term_signal != 0
 #endif
-      ) {
+    ) {
       this->ProcessState = cmProcess::State::Exception;
     } else {
       this->ProcessState = cmProcess::State::Exited;
@@ -375,7 +392,7 @@ cmProcess::Exception cmProcess::GetExitException()
 {
   auto exception = Exception::None;
 #if defined(_WIN32) && !defined(__CYGWIN__)
-  auto exit_code = (DWORD) this->ExitValue;
+  auto exit_code = (DWORD)this->ExitValue;
   if ((exit_code & 0xF0000000) != 0xC0000000) {
     return exception;
   }
@@ -399,12 +416,12 @@ cmProcess::Exception cmProcess::GetExitException()
       case STATUS_FLOAT_OVERFLOW:
       case STATUS_FLOAT_STACK_CHECK:
       case STATUS_FLOAT_UNDERFLOW:
-#ifdef STATUS_FLOAT_MULTIPLE_FAULTS
+#  ifdef STATUS_FLOAT_MULTIPLE_FAULTS
       case STATUS_FLOAT_MULTIPLE_FAULTS:
-#endif
-#ifdef STATUS_FLOAT_MULTIPLE_TRAPS
+#  endif
+#  ifdef STATUS_FLOAT_MULTIPLE_TRAPS
       case STATUS_FLOAT_MULTIPLE_TRAPS:
-#endif
+#  endif
       case STATUS_INTEGER_DIVIDE_BY_ZERO:
       case STATUS_INTEGER_OVERFLOW:
         exception = Exception::Numerical;
@@ -472,16 +489,16 @@ std::string cmProcess::GetExitExceptionString()
     case STATUS_FLOAT_UNDERFLOW:
       exception_str = "Floating-point underflow";
       break;
-#ifdef STATUS_FLOAT_MULTIPLE_FAULTS
+#  ifdef STATUS_FLOAT_MULTIPLE_FAULTS
     case STATUS_FLOAT_MULTIPLE_FAULTS:
       exception_str = "Floating-point exception (multiple faults)";
       break;
-#endif
-#ifdef STATUS_FLOAT_MULTIPLE_TRAPS
+#  endif
+#  ifdef STATUS_FLOAT_MULTIPLE_TRAPS
     case STATUS_FLOAT_MULTIPLE_TRAPS:
       exception_str = "Floating-point exception (multiple traps)";
       break;
-#endif
+#  endif
     case STATUS_INTEGER_DIVIDE_BY_ZERO:
       exception_str = "Integer divide-by-zero";
       break;
@@ -528,188 +545,188 @@ std::string cmProcess::GetExitExceptionString()
   }
 #else
   switch (this->Signal) {
-#ifdef SIGSEGV
+#  ifdef SIGSEGV
     case SIGSEGV:
       exception_str = "Segmentation fault";
       break;
-#endif
-#ifdef SIGBUS
-#if !defined(SIGSEGV) || SIGBUS != SIGSEGV
+#  endif
+#  ifdef SIGBUS
+#    if !defined(SIGSEGV) || SIGBUS != SIGSEGV
     case SIGBUS:
       exception_str = "Bus error";
       break;
-#endif
-#endif
-#ifdef SIGFPE
+#    endif
+#  endif
+#  ifdef SIGFPE
     case SIGFPE:
       exception_str = "Floating-point exception";
       break;
-#endif
-#ifdef SIGILL
+#  endif
+#  ifdef SIGILL
     case SIGILL:
       exception_str = "Illegal instruction";
       break;
-#endif
-#ifdef SIGINT
+#  endif
+#  ifdef SIGINT
     case SIGINT:
       exception_str = "User interrupt";
       break;
-#endif
-#ifdef SIGABRT
+#  endif
+#  ifdef SIGABRT
     case SIGABRT:
       exception_str = "Child aborted";
       break;
-#endif
-#ifdef SIGKILL
+#  endif
+#  ifdef SIGKILL
     case SIGKILL:
       exception_str = "Child killed";
       break;
-#endif
-#ifdef SIGTERM
+#  endif
+#  ifdef SIGTERM
     case SIGTERM:
       exception_str = "Child terminated";
       break;
-#endif
-#ifdef SIGHUP
+#  endif
+#  ifdef SIGHUP
     case SIGHUP:
       exception_str = "SIGHUP";
       break;
-#endif
-#ifdef SIGQUIT
+#  endif
+#  ifdef SIGQUIT
     case SIGQUIT:
       exception_str = "SIGQUIT";
       break;
-#endif
-#ifdef SIGTRAP
+#  endif
+#  ifdef SIGTRAP
     case SIGTRAP:
       exception_str = "SIGTRAP";
       break;
-#endif
-#ifdef SIGIOT
-#if !defined(SIGABRT) || SIGIOT != SIGABRT
+#  endif
+#  ifdef SIGIOT
+#    if !defined(SIGABRT) || SIGIOT != SIGABRT
     case SIGIOT:
       exception_str = "SIGIOT";
       break;
-#endif
-#endif
-#ifdef SIGUSR1
+#    endif
+#  endif
+#  ifdef SIGUSR1
     case SIGUSR1:
       exception_str = "SIGUSR1";
       break;
-#endif
-#ifdef SIGUSR2
+#  endif
+#  ifdef SIGUSR2
     case SIGUSR2:
       exception_str = "SIGUSR2";
       break;
-#endif
-#ifdef SIGPIPE
+#  endif
+#  ifdef SIGPIPE
     case SIGPIPE:
       exception_str = "SIGPIPE";
       break;
-#endif
-#ifdef SIGALRM
+#  endif
+#  ifdef SIGALRM
     case SIGALRM:
       exception_str = "SIGALRM";
       break;
-#endif
-#ifdef SIGSTKFLT
+#  endif
+#  ifdef SIGSTKFLT
     case SIGSTKFLT:
       exception_str = "SIGSTKFLT";
       break;
-#endif
-#ifdef SIGCHLD
+#  endif
+#  ifdef SIGCHLD
     case SIGCHLD:
       exception_str = "SIGCHLD";
       break;
-#elif defined(SIGCLD)
+#  elif defined(SIGCLD)
     case SIGCLD:
       exception_str = "SIGCLD";
       break;
-#endif
-#ifdef SIGCONT
+#  endif
+#  ifdef SIGCONT
     case SIGCONT:
       exception_str = "SIGCONT";
       break;
-#endif
-#ifdef SIGSTOP
+#  endif
+#  ifdef SIGSTOP
     case SIGSTOP:
       exception_str = "SIGSTOP";
       break;
-#endif
-#ifdef SIGTSTP
+#  endif
+#  ifdef SIGTSTP
     case SIGTSTP:
       exception_str = "SIGTSTP";
       break;
-#endif
-#ifdef SIGTTIN
+#  endif
+#  ifdef SIGTTIN
     case SIGTTIN:
       exception_str = "SIGTTIN";
       break;
-#endif
-#ifdef SIGTTOU
+#  endif
+#  ifdef SIGTTOU
     case SIGTTOU:
       exception_str = "SIGTTOU";
       break;
-#endif
-#ifdef SIGURG
+#  endif
+#  ifdef SIGURG
     case SIGURG:
       exception_str = "SIGURG";
       break;
-#endif
-#ifdef SIGXCPU
+#  endif
+#  ifdef SIGXCPU
     case SIGXCPU:
       exception_str = "SIGXCPU";
       break;
-#endif
-#ifdef SIGXFSZ
+#  endif
+#  ifdef SIGXFSZ
     case SIGXFSZ:
       exception_str = "SIGXFSZ";
       break;
-#endif
-#ifdef SIGVTALRM
+#  endif
+#  ifdef SIGVTALRM
     case SIGVTALRM:
       exception_str = "SIGVTALRM";
       break;
-#endif
-#ifdef SIGPROF
+#  endif
+#  ifdef SIGPROF
     case SIGPROF:
       exception_str = "SIGPROF";
       break;
-#endif
-#ifdef SIGWINCH
+#  endif
+#  ifdef SIGWINCH
     case SIGWINCH:
       exception_str = "SIGWINCH";
       break;
-#endif
-#ifdef SIGPOLL
+#  endif
+#  ifdef SIGPOLL
     case SIGPOLL:
       exception_str = "SIGPOLL";
       break;
-#endif
-#ifdef SIGIO
-#if !defined(SIGPOLL) || SIGIO != SIGPOLL
+#  endif
+#  ifdef SIGIO
+#    if !defined(SIGPOLL) || SIGIO != SIGPOLL
     case SIGIO:
       exception_str = "SIGIO";
       break;
-#endif
-#endif
-#ifdef SIGPWR
+#    endif
+#  endif
+#  ifdef SIGPWR
     case SIGPWR:
       exception_str = "SIGPWR";
       break;
-#endif
-#ifdef SIGSYS
+#  endif
+#  ifdef SIGSYS
     case SIGSYS:
       exception_str = "SIGSYS";
       break;
-#endif
-#ifdef SIGUNUSED
-#if !defined(SIGSYS) || SIGUNUSED != SIGSYS
+#  endif
+#  ifdef SIGUNUSED
+#    if !defined(SIGSYS) || SIGUNUSED != SIGSYS
     case SIGUNUSED:
       exception_str = "SIGUNUSED";
       break;
-#endif
-#endif
+#    endif
+#  endif
     default:
       exception_str = "Signal ";
       exception_str += std::to_string(this->Signal);
diff --git a/Source/CTest/cmProcess.h b/Source/CTest/cmProcess.h
index 20e24b9d2..b2d87fab3 100644
--- a/Source/CTest/cmProcess.h
+++ b/Source/CTest/cmProcess.h
@@ -36,7 +36,7 @@ public:
   void ChangeTimeout(cmDuration t);
   void ResetStartTime();
   // Return true if the process starts
-  bool StartProcess(uv_loop_t& loop);
+  bool StartProcess(uv_loop_t& loop, std::vector<size_t>* affinity);
 
   enum class State
   {
diff --git a/Source/Checks/Curses.cmake b/Source/Checks/Curses.cmake
new file mode 100644
index 000000000..2942b666a
--- /dev/null
+++ b/Source/Checks/Curses.cmake
@@ -0,0 +1,41 @@
+message(STATUS "Checking for curses support")
+
+# Try compiling a simple project using curses.
+# Pass in any cache entries that the user may have set.
+set(CMakeCheckCurses_ARGS "")
+foreach(v
+    CURSES_INCLUDE_PATH
+    CURSES_CURSES_LIBRARY
+    CURSES_NCURSES_LIBRARY
+    CURSES_EXTRA_LIBRARY
+    CURSES_FORM_LIBRARY
+    )
+  if(${v})
+    list(APPEND CMakeCheckCurses_ARGS -D${v}=${${v}})
+  endif()
+endforeach()
+file(REMOVE_RECURSE "${CMake_BINARY_DIR}/Source/Checks/Curses-build")
+try_compile(CMakeCheckCurses_COMPILED
+  ${CMake_BINARY_DIR}/Source/Checks/Curses-build
+  ${CMake_SOURCE_DIR}/Source/Checks/Curses
+  CheckCurses # project name
+  CheckCurses # target name
+  CMAKE_FLAGS
+    "-DCMAKE_C_FLAGS:STRING=${CMAKE_C_FLAGS}"
+    ${CMakeCheckCurses_ARGS}
+  OUTPUT_VARIABLE CMakeCheckCurses_OUTPUT
+  )
+
+# Convert result from cache entry to normal variable.
+set(CMakeCheckCurses_COMPILED "${CMakeCheckCurses_COMPILED}")
+unset(CMakeCheckCurses_COMPILED CACHE)
+
+if(CMakeCheckCurses_COMPILED)
+  message(STATUS "Checking for curses support - Success")
+  file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
+    "Checking for curses support passed with the following output:\n${CMakeCheckCurses_OUTPUT}\n\n")
+else()
+  message(STATUS "Checking for curses support - Failed")
+  file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
+    "Checking for curses support failed with the following output:\n${CMakeCheckCurses_OUTPUT}\n\n")
+endif()
diff --git a/Source/Checks/Curses/CMakeLists.txt b/Source/Checks/Curses/CMakeLists.txt
new file mode 100644
index 000000000..17318a33b
--- /dev/null
+++ b/Source/Checks/Curses/CMakeLists.txt
@@ -0,0 +1,25 @@
+cmake_minimum_required(VERSION 3.1)
+if(POLICY CMP0060)
+  cmake_policy(SET CMP0060 NEW)
+endif()
+project(CheckCurses C)
+
+set(CURSES_NEED_NCURSES TRUE)
+find_package(Curses)
+if(NOT CURSES_FOUND)
+  return()
+endif()
+include_directories(${CURSES_INCLUDE_DIRS})
+add_executable(CheckCurses CheckCurses.c)
+target_link_libraries(CheckCurses ${CURSES_LIBRARIES})
+
+foreach(h
+    CURSES_HAVE_CURSES_H
+    CURSES_HAVE_NCURSES_H
+    CURSES_HAVE_NCURSES_NCURSES_H
+    CURSES_HAVE_NCURSES_CURSES_H
+    )
+  if(${h})
+    target_compile_definitions(CheckCurses PRIVATE ${h})
+  endif()
+endforeach()
diff --git a/Source/Checks/Curses/CheckCurses.c b/Source/Checks/Curses/CheckCurses.c
new file mode 100644
index 000000000..7d827e6bf
--- /dev/null
+++ b/Source/Checks/Curses/CheckCurses.c
@@ -0,0 +1,15 @@
+#if defined(CURSES_HAVE_NCURSES_H)
+#  include <ncurses.h>
+#elif defined(CURSES_HAVE_NCURSES_NCURSES_H)
+#  include <ncurses/ncurses.h>
+#elif defined(CURSES_HAVE_NCURSES_CURSES_H)
+#  include <ncurses/curses.h>
+#else
+#  include <curses.h>
+#endif
+
+int main()
+{
+  curses_version();
+  return 0;
+}
diff --git a/Source/Checks/cm_cxx_features.cmake b/Source/Checks/cm_cxx_features.cmake
index 2a1abbab6..1b57fd8e6 100644
--- a/Source/Checks/cm_cxx_features.cmake
+++ b/Source/Checks/cm_cxx_features.cmake
@@ -22,6 +22,8 @@ function(cm_check_cxx_feature name)
     # Filter out warnings caused by local configuration.
     string(REGEX REPLACE "[^\n]*warning:[^\n]*directory not found for option[^\n]*" "" check_output "${check_output}")
     string(REGEX REPLACE "[^\n]*warning:[^\n]*object file compiled with -mlong-branch which is no longer needed[^\n]*" "" check_output "${check_output}")
+    # Filter out xcodebuild warnings.
+    string(REGEX REPLACE "[^\n]* xcodebuild\\[[0-9]*:[0-9]*\\] warning: [^\n]*" "" check_output "${check_output}")
     # If using the feature causes warnings, treat it as broken/unavailable.
     if(check_output MATCHES "[Ww]arning")
       set(CMake_HAVE_CXX_${FEATURE} OFF CACHE INTERNAL "TRY_COMPILE" FORCE)
diff --git a/Source/CursesDialog/ccmake.cxx b/Source/CursesDialog/ccmake.cxx
index 17cf6289a..a3e071716 100644
--- a/Source/CursesDialog/ccmake.cxx
+++ b/Source/CursesDialog/ccmake.cxx
@@ -22,11 +22,13 @@ static const char* cmDocumentationName[][2] = {
 };
 
 static const char* cmDocumentationUsage[][2] = {
-  { nullptr, "  ccmake <path-to-source>\n"
-             "  ccmake <path-to-existing-build>" },
-  { nullptr, "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." },
+  { nullptr,
+    "  ccmake <path-to-source>\n"
+    "  ccmake <path-to-existing-build>" },
+  { nullptr,
+    "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." },
   { nullptr, nullptr }
 };
 
@@ -35,9 +37,10 @@ static const char* cmDocumentationUsageNote[][2] = {
   { nullptr, nullptr }
 };
 
-static const char* cmDocumentationOptions[]
-                                         [2] = { CMAKE_STANDARD_OPTIONS_TABLE,
-                                                 { nullptr, nullptr } };
+static const char* cmDocumentationOptions[][2] = {
+  CMAKE_STANDARD_OPTIONS_TABLE,
+  { nullptr, nullptr }
+};
 
 cmCursesForm* cmCursesForm::CurrentForm = nullptr;
 
diff --git a/Source/CursesDialog/cmCursesMainForm.cxx b/Source/CursesDialog/cmCursesMainForm.cxx
index 4a9dc473c..4a379c39d 100644
--- a/Source/CursesDialog/cmCursesMainForm.cxx
+++ b/Source/CursesDialog/cmCursesMainForm.cxx
@@ -371,8 +371,9 @@ void cmCursesMainForm::PrintKeys(int process /* = 0 */)
         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);
@@ -412,9 +413,10 @@ void cmCursesMainForm::UpdateStatusBar(const char* message)
     curses_clear();
     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);
@@ -568,10 +570,11 @@ int cmCursesMainForm::Configure(int noconfigure)
     }
     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.");
+    cmCursesLongMessageForm* msgs =
+      new cmCursesLongMessageForm(this->Errors,
+                                  cmSystemTools::GetErrorOccuredFlag()
+                                    ? "Errors occurred during the last pass."
+                                    : "CMake produced the following output.");
     // reset error condition
     cmSystemTools::ResetErrorOccuredFlag();
     CurrentForm = msgs;
diff --git a/Source/CursesDialog/cmCursesMainForm.h b/Source/CursesDialog/cmCursesMainForm.h
index 7f5b3cad6..2c006cfb8 100644
--- a/Source/CursesDialog/cmCursesMainForm.h
+++ b/Source/CursesDialog/cmCursesMainForm.h
@@ -125,7 +125,7 @@ protected:
   std::vector<cmCursesCacheEntryComposite*>* Entries;
   // Errors produced during last run of cmake
   std::vector<std::string> Errors;
-  // Command line argumens to be passed to cmake each time
+  // Command line arguments to be passed to cmake each time
   // it is run
   std::vector<std::string> Args;
   // Message displayed when user presses 'h'
diff --git a/Source/CursesDialog/cmCursesStandardIncludes.h b/Source/CursesDialog/cmCursesStandardIncludes.h
index 332d2af08..5b0ad5824 100644
--- a/Source/CursesDialog/cmCursesStandardIncludes.h
+++ b/Source/CursesDialog/cmCursesStandardIncludes.h
@@ -5,9 +5,14 @@
 
 #include "cmConfigure.h" // IWYU pragma: keep
 
+// Record whether __attribute__ is currently defined.  See purpose below.
+#ifndef __attribute__
+#  define cm_no__attribute__
+#endif
+
 #if defined(__hpux)
-#define _BOOL_DEFINED
-#include <sys/time.h>
+#  define _BOOL_DEFINED
+#  include <sys/time.h>
 #endif
 
 #include <form.h>
@@ -29,4 +34,12 @@ inline void curses_clear()
 #undef erase
 #undef clear
 
+// The curses headers on some platforms (e.g. Solaris) may
+// define __attribute__ as a macro.  This breaks C++ headers
+// in some cases, so undefine it now.
+#if defined(cm_no__attribute__) && defined(__attribute__)
+#  undef __attribute__
+#endif
+#undef cm_no__attribute__
+
 #endif // cmCursesStandardIncludes_h
diff --git a/Source/CursesDialog/form/frm_post.c b/Source/CursesDialog/form/frm_post.c
index 924fe6a9e..fc0a35946 100644
--- a/Source/CursesDialog/form/frm_post.c
+++ b/Source/CursesDialog/form/frm_post.c
@@ -67,7 +67,7 @@ int post_form(FORM * form)
   if ((form->cols > width) || (form->rows > height))
     RETURN(E_NO_ROOM);
 
-  /* reset form->curpage to an invald value. This forces Set_Form_Page
+  /* reset form->curpage to an invalid value. This forces Set_Form_Page
      to do the page initialization which is required by post_form.
   */
   page = form->curpage;
diff --git a/Source/LexerParser/cmFortranParser.cxx b/Source/LexerParser/cmFortranParser.cxx
index 2b3452f2e..00c8a8afc 100644
--- a/Source/LexerParser/cmFortranParser.cxx
+++ b/Source/LexerParser/cmFortranParser.cxx
@@ -1563,7 +1563,7 @@ yyreduce:
 #line 119 "cmFortranParser.y" /* yacc.c:1646  */
     {
     cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
-    cmFortranParser_RuleUse(parser, (yyvsp[-4].string));
+    cmFortranParser_RuleSubmodule(parser, (yyvsp[-4].string), (yyvsp[-2].string));
     free((yyvsp[-4].string));
     free((yyvsp[-2].string));
   }
@@ -1574,7 +1574,7 @@ yyreduce:
 #line 125 "cmFortranParser.y" /* yacc.c:1646  */
     {
     cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
-    cmFortranParser_RuleUse(parser, (yyvsp[-6].string));
+    cmFortranParser_RuleSubmoduleNested(parser, (yyvsp[-6].string), (yyvsp[-4].string), (yyvsp[-2].string));
     free((yyvsp[-6].string));
     free((yyvsp[-4].string));
     free((yyvsp[-2].string));
diff --git a/Source/LexerParser/cmFortranParser.y b/Source/LexerParser/cmFortranParser.y
index acfb40ad8..5e0924872 100644
--- a/Source/LexerParser/cmFortranParser.y
+++ b/Source/LexerParser/cmFortranParser.y
@@ -118,13 +118,13 @@ stmt:
   }
 | SUBMODULE LPAREN WORD RPAREN WORD other EOSTMT {
     cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
-    cmFortranParser_RuleUse(parser, $3);
+    cmFortranParser_RuleSubmodule(parser, $3, $5);
     free($3);
     free($5);
   }
 | SUBMODULE LPAREN WORD COLON WORD RPAREN WORD other EOSTMT {
     cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
-    cmFortranParser_RuleUse(parser, $3);
+    cmFortranParser_RuleSubmoduleNested(parser, $3, $5, $7);
     free($3);
     free($5);
     free($7);
diff --git a/Source/LexerParser/cmListFileLexer.c b/Source/LexerParser/cmListFileLexer.c
index c6f524c6b..eb373373f 100644
--- a/Source/LexerParser/cmListFileLexer.c
+++ b/Source/LexerParser/cmListFileLexer.c
@@ -576,16 +576,16 @@ struct yy_trans_info
 	flex_int32_t yy_verify;
 	flex_int32_t yy_nxt;
 	};
-static const flex_int16_t yy_accept[81] =
+static const flex_int16_t yy_accept[79] =
     {   0,
         0,    0,    0,    0,    0,    0,    0,    0,    4,    4,
        25,   13,   22,    1,   16,    3,   13,    5,    6,    7,
-       15,   23,   23,   17,   19,   20,   21,   17,   10,   11,
-        8,   10,   12,    9,   24,    4,   13,    0,   13,    0,
-       22,    0,    0,    7,   13,    0,   13,    0,    2,    0,
-       13,   17,    0,   18,   10,    8,    4,    0,   14,    0,
-        0,    0,    0,   14,    0,    0,   14,    0,    0,    0,
-        2,   14,    0,    0,    0,    0,    0,    0,    0,    0
+       15,   23,   23,   17,   19,   20,   21,   24,   10,   11,
+        8,   12,    9,    4,   13,    0,   13,    0,   22,    0,
+        0,    7,   13,    0,   13,    0,    2,    0,   13,   17,
+        0,   18,   10,    8,    4,    0,   14,    0,    0,    0,
+        0,   14,    0,    0,   14,    0,    0,    0,    2,   14,
+        0,    0,    0,    0,    0,    0,    0,    0
     } ;
 
 static const YY_CHAR yy_ec[256] =
@@ -623,89 +623,87 @@ static const YY_CHAR yy_ec[256] =
 static const YY_CHAR yy_meta[17] =
     {   0,
         1,    1,    2,    3,    4,    3,    1,    3,    5,    6,
-        1,    6,    1,    1,    7,    8
+        1,    6,    1,    1,    7,    2
     } ;
 
-static const flex_int16_t yy_base[99] =
+static const flex_int16_t yy_base[97] =
     {   0,
         0,    0,   14,   28,   42,   56,   70,   84,   18,   19,
-       69,  100,   16,  323,  323,   55,   59,  323,  323,   13,
-      115,    0,  323,   52,  323,  323,   21,   51,    0,  323,
-       53,    0,  323,  323,  323,    0,    0,  126,   55,    0,
-       25,   25,   53,    0,    0,  136,   53,    0,   57,    0,
-        0,   42,   50,  323,    0,   43,    0,  146,  160,   45,
-      172,   43,   26,    0,   42,  184,    0,   42,  195,   40,
-      323,   40,    0,   38,   37,   34,   32,   31,   23,  323,
-      211,  219,  227,  235,  243,  251,  259,  267,  274,  281,
-      285,  291,  298,  302,  304,  310,  314,  316
+       68,  100,   16,  298,  298,   54,   58,  298,  298,   13,
+      115,    0,  298,   51,  298,  298,   21,  298,    0,  298,
+       53,  298,  298,    0,    0,  126,   55,    0,   25,   25,
+       53,    0,    0,  136,   53,    0,   57,    0,    0,   42,
+       50,  298,    0,   43,    0,  146,  160,   45,  172,   43,
+       26,    0,   42,  177,    0,   42,  188,   40,  298,   40,
+        0,   38,   37,   34,   32,   31,   23,  298,  197,  204,
+      211,  218,  225,  232,  239,  245,  252,  259,  262,  268,
+      275,  278,  280,  286,  289,  291
 
     } ;
 
-static const flex_int16_t yy_def[99] =
+static const flex_int16_t yy_def[97] =
     {   0,
-       80,    1,   81,   81,   82,   82,   83,   83,   84,   84,
-       80,   80,   80,   80,   80,   80,   12,   80,   80,   12,
-       80,   85,   80,   86,   80,   80,   86,   86,   87,   80,
-       80,   87,   80,   80,   80,   88,   12,   89,   12,   90,
-       80,   80,   91,   20,   12,   92,   12,   21,   80,   93,
-       12,   86,   86,   80,   87,   80,   88,   89,   80,   58,
-       89,   94,   80,   59,   91,   92,   59,   66,   92,   95,
-       80,   59,   96,   97,   94,   98,   95,   97,   98,    0,
-       80,   80,   80,   80,   80,   80,   80,   80,   80,   80,
-       80,   80,   80,   80,   80,   80,   80,   80
+       78,    1,   79,   79,   80,   80,   81,   81,   82,   82,
+       78,   78,   78,   78,   78,   78,   12,   78,   78,   12,
+       78,   83,   78,   84,   78,   78,   84,   78,   85,   78,
+       78,   78,   78,   86,   12,   87,   12,   88,   78,   78,
+       89,   20,   12,   90,   12,   21,   78,   91,   12,   84,
+       84,   78,   85,   78,   86,   87,   78,   56,   87,   92,
+       78,   57,   89,   90,   57,   64,   90,   93,   78,   57,
+       94,   95,   92,   96,   93,   95,   96,    0,   78,   78,
+       78,   78,   78,   78,   78,   78,   78,   78,   78,   78,
+       78,   78,   78,   78,   78,   78
 
     } ;
 
-static const flex_int16_t yy_nxt[340] =
+static const flex_int16_t yy_nxt[315] =
     {   0,
        12,   13,   14,   13,   15,   16,   17,   18,   19,   12,
-       12,   20,   21,   22,   12,   23,   25,   41,   26,   41,
-       14,   14,   44,   54,   44,   52,   41,   27,   41,   28,
-       25,   66,   26,   35,   35,   63,   63,   49,   49,   58,
-       67,   27,   66,   28,   30,   59,   58,   62,   67,   76,
-       64,   59,   74,   56,   52,   53,   31,   32,   30,   71,
-       70,   64,   62,   56,   53,   53,   43,   42,   80,   80,
-       31,   32,   30,   80,   80,   80,   80,   80,   80,   80,
-       80,   80,   80,   80,   34,   35,   30,   80,   80,   80,
-       80,   80,   80,   80,   80,   80,   80,   80,   34,   35,
-
-       37,   80,   80,   80,   38,   80,   39,   80,   80,   37,
-       37,   37,   37,   40,   37,   45,   80,   80,   80,   46,
-       80,   47,   80,   80,   45,   48,   45,   49,   50,   45,
-       59,   80,   60,   80,   80,   80,   80,   80,   80,   61,
-       67,   80,   68,   80,   80,   80,   80,   80,   80,   69,
-       59,   80,   60,   80,   80,   80,   80,   80,   80,   61,
-       59,   80,   80,   80,   38,   80,   72,   80,   80,   59,
-       59,   59,   59,   73,   59,   58,   80,   58,   80,   58,
-       58,   80,   80,   80,   80,   80,   80,   58,   67,   80,
-       68,   80,   80,   80,   80,   80,   80,   69,   66,   80,
-
-       66,   80,   66,   66,   80,   80,   80,   80,   80,   80,
-       66,   24,   24,   24,   24,   24,   24,   24,   24,   29,
-       29,   29,   29,   29,   29,   29,   29,   33,   33,   33,
-       33,   33,   33,   33,   33,   36,   36,   36,   36,   36,
-       36,   36,   36,   51,   80,   51,   51,   51,   51,   51,
-       51,   52,   80,   52,   80,   52,   52,   52,   52,   55,
-       80,   55,   55,   55,   55,   80,   55,   57,   80,   57,
-       57,   57,   57,   57,   58,   80,   80,   58,   80,   58,
-       58,   37,   80,   37,   37,   37,   37,   37,   37,   65,
-       65,   66,   80,   80,   66,   80,   66,   66,   45,   80,
-
-       45,   45,   45,   45,   45,   45,   75,   75,   77,   77,
-       59,   80,   59,   59,   59,   59,   59,   59,   78,   78,
-       79,   79,   11,   80,   80,   80,   80,   80,   80,   80,
-       80,   80,   80,   80,   80,   80,   80,   80,   80
+       12,   20,   21,   22,   12,   23,   25,   39,   26,   39,
+       14,   14,   42,   52,   42,   50,   39,   27,   39,   28,
+       25,   64,   26,   28,   28,   61,   61,   47,   47,   56,
+       65,   27,   64,   28,   30,   57,   56,   60,   65,   74,
+       62,   57,   72,   54,   50,   51,   31,   28,   30,   69,
+       68,   62,   60,   54,   51,   41,   40,   78,   78,   78,
+       31,   28,   30,   78,   78,   78,   78,   78,   78,   78,
+       78,   78,   78,   78,   33,   28,   30,   78,   78,   78,
+       78,   78,   78,   78,   78,   78,   78,   78,   33,   28,
+
+       35,   78,   78,   78,   36,   78,   37,   78,   78,   35,
+       35,   35,   35,   38,   35,   43,   78,   78,   78,   44,
+       78,   45,   78,   78,   43,   46,   43,   47,   48,   43,
+       57,   78,   58,   78,   78,   78,   78,   78,   78,   59,
+       65,   78,   66,   78,   78,   78,   78,   78,   78,   67,
+       57,   78,   58,   78,   78,   78,   78,   78,   78,   59,
+       57,   78,   78,   78,   36,   78,   70,   78,   78,   57,
+       57,   57,   57,   71,   57,   56,   78,   56,   78,   56,
+       56,   65,   78,   66,   78,   78,   78,   78,   78,   78,
+       67,   64,   78,   64,   78,   64,   64,   24,   24,   24,
+
+       24,   24,   24,   24,   29,   29,   29,   29,   29,   29,
+       29,   32,   32,   32,   32,   32,   32,   32,   34,   34,
+       34,   34,   34,   34,   34,   49,   78,   49,   49,   49,
+       49,   49,   50,   78,   50,   78,   50,   50,   50,   53,
+       78,   53,   53,   53,   53,   55,   78,   55,   55,   55,
+       55,   55,   56,   78,   78,   56,   78,   56,   56,   35,
+       78,   35,   35,   35,   35,   35,   63,   63,   64,   78,
+       78,   64,   78,   64,   64,   43,   78,   43,   43,   43,
+       43,   43,   73,   73,   75,   75,   57,   78,   57,   57,
+       57,   57,   57,   76,   76,   77,   77,   11,   78,   78,
+
+       78,   78,   78,   78,   78,   78,   78,   78,   78,   78,
+       78,   78,   78,   78
     } ;
 
-static const flex_int16_t yy_chk[340] =
+static const flex_int16_t yy_chk[315] =
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    3,   13,    3,   13,
-        9,   10,   20,   27,   20,   27,   41,    3,   41,    3,
-        4,   79,    4,    9,   10,   42,   63,   42,   63,   78,
-       77,    4,   76,    4,    5,   75,   74,   72,   70,   68,
-       65,   62,   60,   56,   53,   52,    5,    5,    6,   49,
-       47,   43,   39,   31,   28,   24,   17,   16,   11,    0,
+        9,   10,   20,   27,   20,   27,   39,    3,   39,    3,
+        4,   77,    4,    9,   10,   40,   61,   40,   61,   76,
+       75,    4,   74,    4,    5,   73,   72,   70,   68,   66,
+       63,   60,   58,   54,   51,   50,    5,    5,    6,   47,
+       45,   41,   37,   31,   24,   17,   16,   11,    0,    0,
         6,    6,    7,    0,    0,    0,    0,    0,    0,    0,
         0,    0,    0,    0,    7,    7,    8,    0,    0,    0,
         0,    0,    0,    0,    0,    0,    0,    0,    8,    8,
@@ -713,29 +711,27 @@ static const flex_int16_t yy_chk[340] =
        12,    0,    0,    0,   12,    0,   12,    0,    0,   12,
        12,   12,   12,   12,   12,   21,    0,    0,    0,   21,
         0,   21,    0,    0,   21,   21,   21,   21,   21,   21,
-       38,    0,   38,    0,    0,    0,    0,    0,    0,   38,
-       46,    0,   46,    0,    0,    0,    0,    0,    0,   46,
-       58,    0,   58,    0,    0,    0,    0,    0,    0,   58,
-       59,    0,    0,    0,   59,    0,   59,    0,    0,   59,
-       59,   59,   59,   59,   59,   61,    0,   61,    0,   61,
-       61,    0,    0,    0,    0,    0,    0,   61,   66,    0,
-       66,    0,    0,    0,    0,    0,    0,   66,   69,    0,
-
-       69,    0,   69,   69,    0,    0,    0,    0,    0,    0,
-       69,   81,   81,   81,   81,   81,   81,   81,   81,   82,
-       82,   82,   82,   82,   82,   82,   82,   83,   83,   83,
-       83,   83,   83,   83,   83,   84,   84,   84,   84,   84,
-       84,   84,   84,   85,    0,   85,   85,   85,   85,   85,
-       85,   86,    0,   86,    0,   86,   86,   86,   86,   87,
-        0,   87,   87,   87,   87,    0,   87,   88,    0,   88,
-       88,   88,   88,   88,   89,    0,    0,   89,    0,   89,
-       89,   90,    0,   90,   90,   90,   90,   90,   90,   91,
-       91,   92,    0,    0,   92,    0,   92,   92,   93,    0,
-
-       93,   93,   93,   93,   93,   93,   94,   94,   95,   95,
-       96,    0,   96,   96,   96,   96,   96,   96,   97,   97,
-       98,   98,   80,   80,   80,   80,   80,   80,   80,   80,
-       80,   80,   80,   80,   80,   80,   80,   80,   80
+       36,    0,   36,    0,    0,    0,    0,    0,    0,   36,
+       44,    0,   44,    0,    0,    0,    0,    0,    0,   44,
+       56,    0,   56,    0,    0,    0,    0,    0,    0,   56,
+       57,    0,    0,    0,   57,    0,   57,    0,    0,   57,
+       57,   57,   57,   57,   57,   59,    0,   59,    0,   59,
+       59,   64,    0,   64,    0,    0,    0,    0,    0,    0,
+       64,   67,    0,   67,    0,   67,   67,   79,   79,   79,
+
+       79,   79,   79,   79,   80,   80,   80,   80,   80,   80,
+       80,   81,   81,   81,   81,   81,   81,   81,   82,   82,
+       82,   82,   82,   82,   82,   83,    0,   83,   83,   83,
+       83,   83,   84,    0,   84,    0,   84,   84,   84,   85,
+        0,   85,   85,   85,   85,   86,    0,   86,   86,   86,
+       86,   86,   87,    0,    0,   87,    0,   87,   87,   88,
+        0,   88,   88,   88,   88,   88,   89,   89,   90,    0,
+        0,   90,    0,   90,   90,   91,    0,   91,   91,   91,
+       91,   91,   92,   92,   93,   93,   94,    0,   94,   94,
+       94,   94,   94,   95,   95,   96,   96,   78,   78,   78,
+
+       78,   78,   78,   78,   78,   78,   78,   78,   78,   78,
+       78,   78,   78,   78
     } ;
 
 /* Table of booleans, true if rule could match eol. */
@@ -1093,13 +1089,13 @@ yy_match:
 			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 				{
 				yy_current_state = (int) yy_def[yy_current_state];
-				if ( yy_current_state >= 81 )
+				if ( yy_current_state >= 79 )
 					yy_c = yy_meta[yy_c];
 				}
 			yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
 			++yy_cp;
 			}
-		while ( yy_base[yy_current_state] != 323 );
+		while ( yy_base[yy_current_state] != 298 );
 
 yy_find_action:
 		yy_act = yy_accept[yy_current_state];
@@ -1674,7 +1670,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 			{
 			yy_current_state = (int) yy_def[yy_current_state];
-			if ( yy_current_state >= 81 )
+			if ( yy_current_state >= 79 )
 				yy_c = yy_meta[yy_c];
 			}
 		yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
@@ -1703,11 +1699,11 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 		{
 		yy_current_state = (int) yy_def[yy_current_state];
-		if ( yy_current_state >= 81 )
+		if ( yy_current_state >= 79 )
 			yy_c = yy_meta[yy_c];
 		}
 	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
-	yy_is_jam = (yy_current_state == 80);
+	yy_is_jam = (yy_current_state == 78);
 
 	(void)yyg;
 	return yy_is_jam ? 0 : yy_current_state;
diff --git a/Source/LexerParser/cmListFileLexer.in.l b/Source/LexerParser/cmListFileLexer.in.l
index f2fd5389d..23c7e4915 100644
--- a/Source/LexerParser/cmListFileLexer.in.l
+++ b/Source/LexerParser/cmListFileLexer.in.l
@@ -74,7 +74,7 @@ static void cmListFileLexerDestroy(cmListFileLexer* lexer);
 %x COMMENT
 
 MAKEVAR \$\([A-Za-z0-9_]*\)
-UNQUOTED ([^ \0\t\r\n\(\)#\\\"[=]|\\.)
+UNQUOTED ([^ \0\t\r\n\(\)#\\\"[=]|\\[^\0\n])
 LEGACY {MAKEVAR}|{UNQUOTED}|\"({MAKEVAR}|{UNQUOTED}|[ \t[=])*\"
 
 %%
@@ -156,7 +156,7 @@ LEGACY {MAKEVAR}|{UNQUOTED}|\"({MAKEVAR}|{UNQUOTED}|[ \t[=])*\"
   return 1;
 }
 
-<BRACKET>([^]\n])+ {
+<BRACKET>([^]\0\n])+ {
   cmListFileLexerAppend(lexer, yytext, yyleng);
   lexer->column += yyleng;
 }
@@ -208,7 +208,7 @@ LEGACY {MAKEVAR}|{UNQUOTED}|\"({MAKEVAR}|{UNQUOTED}|[ \t[=])*\"
   BEGIN(STRING);
 }
 
-<STRING>([^\\\n\"]|\\.)+ {
+<STRING>([^\\\0\n\"]|\\[^\0\n])+ {
   cmListFileLexerAppend(lexer, yytext, yyleng);
   lexer->column += yyleng;
 }
diff --git a/Source/Modules/FindLibUV.cmake b/Source/Modules/FindLibUV.cmake
index ba13d75f8..0554d62c2 100644
--- a/Source/Modules/FindLibUV.cmake
+++ b/Source/Modules/FindLibUV.cmake
@@ -63,6 +63,8 @@ mark_as_advanced(LibUV_INCLUDE_DIR)
 set(_LibUV_H_REGEX "#[ \t]*define[ \t]+UV_VERSION_(MAJOR|MINOR|PATCH)[ \t]+[0-9]+")
 if(LibUV_INCLUDE_DIR AND EXISTS "${LibUV_INCLUDE_DIR}/uv-version.h")
   file(STRINGS "${LibUV_INCLUDE_DIR}/uv-version.h" _LibUV_H REGEX "${_LibUV_H_REGEX}")
+elseif(LibUV_INCLUDE_DIR AND EXISTS "${LibUV_INCLUDE_DIR}/uv/version.h")
+  file(STRINGS "${LibUV_INCLUDE_DIR}/uv/version.h" _LibUV_H REGEX "${_LibUV_H_REGEX}")
 elseif(LibUV_INCLUDE_DIR AND EXISTS "${LibUV_INCLUDE_DIR}/uv.h")
   file(STRINGS "${LibUV_INCLUDE_DIR}/uv.h" _LibUV_H REGEX "${_LibUV_H_REGEX}")
 else()
diff --git a/Source/QtDialog/AddCacheEntry.h b/Source/QtDialog/AddCacheEntry.h
index cc710f558..65e11c06d 100644
--- a/Source/QtDialog/AddCacheEntry.h
+++ b/Source/QtDialog/AddCacheEntry.h
@@ -11,7 +11,9 @@
 
 #include "ui_AddCacheEntry.h"
 
-class AddCacheEntry : public QWidget, public Ui::AddCacheEntry
+class AddCacheEntry
+  : public QWidget
+  , public Ui::AddCacheEntry
 {
   Q_OBJECT
 public:
diff --git a/Source/QtDialog/CMakeSetup.cxx b/Source/QtDialog/CMakeSetup.cxx
index 193f4d323..2646c9aac 100644
--- a/Source/QtDialog/CMakeSetup.cxx
+++ b/Source/QtDialog/CMakeSetup.cxx
@@ -27,9 +27,10 @@ static const char* cmDocumentationName[][2] = { { nullptr,
                                                 { nullptr, nullptr } };
 
 static const char* cmDocumentationUsage[][2] = {
-  { nullptr, "  cmake-gui [options]\n"
-             "  cmake-gui [options] <path-to-source>\n"
-             "  cmake-gui [options] <path-to-existing-build>" },
+  { nullptr,
+    "  cmake-gui [options]\n"
+    "  cmake-gui [options] <path-to-source>\n"
+    "  cmake-gui [options] <path-to-existing-build>" },
   { nullptr, nullptr }
 };
 
@@ -192,10 +193,10 @@ int main(int argc, char** argv)
 }
 
 #if defined(Q_OS_MAC)
-#include "cm_sys_stat.h"
-#include <errno.h>
-#include <string.h>
-#include <unistd.h>
+#  include "cm_sys_stat.h"
+#  include <errno.h>
+#  include <string.h>
+#  include <unistd.h>
 static bool cmOSXInstall(std::string const& dir, std::string const& tool)
 {
   if (tool.empty()) {
diff --git a/Source/QtDialog/CMakeSetupDialog.cxx b/Source/QtDialog/CMakeSetupDialog.cxx
index 5be9ec38d..5d589cc08 100644
--- a/Source/QtDialog/CMakeSetupDialog.cxx
+++ b/Source/QtDialog/CMakeSetupDialog.cxx
@@ -842,7 +842,7 @@ void CMakeSetupDialog::doAbout()
     "Qt is licensed under terms of the GNU LGPLv" USE_LGPL ", available at:\n"
     " \"%3\""
 #endif
-    );
+  );
   msg = msg.arg(cmVersion::GetCMakeVersion());
   msg = msg.arg(qVersion());
 #ifdef USE_LGPL
@@ -989,8 +989,9 @@ void CMakeSetupDialog::removeSelectedCacheEntries()
 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 {
     this->RemoveEntry->setEnabled(false);
diff --git a/Source/QtDialog/CMakeSetupDialog.h b/Source/QtDialog/CMakeSetupDialog.h
index 7b767e598..1cce35c0b 100644
--- a/Source/QtDialog/CMakeSetupDialog.h
+++ b/Source/QtDialog/CMakeSetupDialog.h
@@ -16,7 +16,9 @@ class QProgressBar;
 class QToolButton;
 
 /// Qt user interface for CMake
-class CMakeSetupDialog : public QMainWindow, public Ui::CMakeSetupDialog
+class CMakeSetupDialog
+  : public QMainWindow
+  , public Ui::CMakeSetupDialog
 {
   Q_OBJECT
 public:
diff --git a/Source/QtDialog/Compilers.h b/Source/QtDialog/Compilers.h
index 746266cbb..96770e3f4 100644
--- a/Source/QtDialog/Compilers.h
+++ b/Source/QtDialog/Compilers.h
@@ -9,7 +9,9 @@
 
 #include <ui_Compilers.h>
 
-class Compilers : public QWidget, public Ui::Compilers
+class Compilers
+  : public QWidget
+  , public Ui::Compilers
 {
   Q_OBJECT
 public:
diff --git a/Source/QtDialog/FirstConfigure.h b/Source/QtDialog/FirstConfigure.h
index c467ddb19..abfa03fd8 100644
--- a/Source/QtDialog/FirstConfigure.h
+++ b/Source/QtDialog/FirstConfigure.h
@@ -63,7 +63,9 @@ private:
 };
 
 //! the page that gives basic options for native compilers
-class NativeCompilerSetup : public QWizardPage, protected Ui::Compilers
+class NativeCompilerSetup
+  : public QWizardPage
+  , protected Ui::Compilers
 {
   Q_OBJECT
 public:
@@ -83,7 +85,9 @@ public:
 };
 
 //! the page that gives options for cross compilers
-class CrossCompilerSetup : public QWizardPage, protected Ui::CrossCompiler
+class CrossCompilerSetup
+  : public QWizardPage
+  , protected Ui::CrossCompiler
 {
   Q_OBJECT
 public:
diff --git a/Source/QtDialog/QCMake.cxx b/Source/QtDialog/QCMake.cxx
index a84429b8a..0e14a3f7d 100644
--- a/Source/QtDialog/QCMake.cxx
+++ b/Source/QtDialog/QCMake.cxx
@@ -10,7 +10,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)
diff --git a/Source/QtDialog/QCMake.h b/Source/QtDialog/QCMake.h
index 6fae7e3f5..4b3920aaf 100644
--- a/Source/QtDialog/QCMake.h
+++ b/Source/QtDialog/QCMake.h
@@ -8,8 +8,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>
diff --git a/Source/QtDialog/RegexExplorer.h b/Source/QtDialog/RegexExplorer.h
index 867989279..c7dbb76cd 100644
--- a/Source/QtDialog/RegexExplorer.h
+++ b/Source/QtDialog/RegexExplorer.h
@@ -12,7 +12,9 @@
 class QString;
 class QWidget;
 
-class RegexExplorer : public QDialog, public Ui::RegexExplorer
+class RegexExplorer
+  : public QDialog
+  , public Ui::RegexExplorer
 {
   Q_OBJECT
 public:
diff --git a/Source/QtDialog/WarningMessagesDialog.h b/Source/QtDialog/WarningMessagesDialog.h
index acb830d85..9b29ad63c 100644
--- a/Source/QtDialog/WarningMessagesDialog.h
+++ b/Source/QtDialog/WarningMessagesDialog.h
@@ -12,7 +12,9 @@
 /**
  * Dialog window for setting the warning message related options.
  */
-class WarningMessagesDialog : public QDialog, public Ui_MessagesDialog
+class WarningMessagesDialog
+  : public QDialog
+  , public Ui_MessagesDialog
 {
   Q_OBJECT
 
diff --git a/Source/bindexplib.cxx b/Source/bindexplib.cxx
index 9ec9624ef..a1072948f 100644
--- a/Source/bindexplib.cxx
+++ b/Source/bindexplib.cxx
@@ -8,26 +8,26 @@
 -------------------------------------------------------------------------*/
 
 /*
-*----------------------------------------------------------------------
-* Program:  dumpexts.exe
-* Author:   Gordon Chaffee
-*
-* History:  The real functionality of this file was written by
-*           Matt Pietrek in 1993 in his pedump utility.  I've
-*           modified it to dump the externals in a bunch of object
-*           files to create a .def file.
-*
-* Notes:    Visual C++ puts an underscore before each exported symbol.
-*           This file removes them.  I don't know if this is a problem
-*           this other compilers.  If _MSC_VER is defined,
-*           the underscore is removed.  If not, it isn't.  To get a
-*           full dump of an object file, use the -f option.  This can
-*           help determine the something that may be different with a
-*           compiler other than Visual C++.
-*   ======================================
-* Corrections (Axel 2006-04-04):
-*   Conversion to C++. Mostly.
-*
+ *----------------------------------------------------------------------
+ * Program:  dumpexts.exe
+ * Author:   Gordon Chaffee
+ *
+ * History:  The real functionality of this file was written by
+ *           Matt Pietrek in 1993 in his pedump utility.  I've
+ *           modified it to dump the externals in a bunch of object
+ *           files to create a .def file.
+ *
+ * Notes:    Visual C++ puts an underscore before each exported symbol.
+ *           This file removes them.  I don't know if this is a problem
+ *           this other compilers.  If _MSC_VER is defined,
+ *           the underscore is removed.  If not, it isn't.  To get a
+ *           full dump of an object file, use the -f option.  This can
+ *           help determine the something that may be different with a
+ *           compiler other than Visual C++.
+ *   ======================================
+ * Corrections (Axel 2006-04-04):
+ *   Conversion to C++. Mostly.
+ *
  * Extension (Axel 2006-03-15)
  *    As soon as an object file contains an /EXPORT directive (which
  *    is generated by the compiler when a symbol is declared as
@@ -37,30 +37,31 @@
  *    programmer).
  *
  *   ======================================
-*   ======================================
-* Corrections (Valery Fine 23/02/98):
-*
-*           The "(vector) deleting destructor" MUST not be exported
-*           To recognize it the following test are introduced:
-*  "@@UAEPAXI@Z"  scalar deleting dtor
-*  "@@QAEPAXI@Z"  vector deleting dtor
-*  "AEPAXI@Z"     vector deleting dtor with thunk adjustor
-*   ======================================
-* Corrections (Valery Fine 12/02/97):
-*
-*    It created a wrong EXPORTS for the global pointers and constants.
-*    The Section Header has been involved to discover the missing information
-*    Now the pointers are correctly supplied with "DATA" descriptor
-*        the constants  with no extra descriptor.
-*
-* Corrections (Valery Fine 16/09/96):
-*
-*     It didn't work for C++ code with global variables and class definitions
-*     The DumpExternalObject function has been introduced to generate .DEF file
-*
-* Author:   Valery Fine 16/09/96  (E-mail: fine@vxcern.cern.ch)
-*----------------------------------------------------------------------
-*/
+ *   ======================================
+ * Corrections (Valery Fine 23/02/98):
+ *
+ *           The "(vector) deleting destructor" MUST not be exported
+ *           To recognize it the following test are introduced:
+ *  "@@UAEPAXI@Z"  scalar deleting dtor
+ *  "@@QAEPAXI@Z"  vector deleting dtor
+ *  "AEPAXI@Z"     vector deleting dtor with thunk adjustor
+ *   ======================================
+ * Corrections (Valery Fine 12/02/97):
+ *
+ *    It created a wrong EXPORTS for the global pointers and constants.
+ *    The Section Header has been involved to discover the missing information
+ *    Now the pointers are correctly supplied with "DATA" descriptor
+ *        the constants  with no extra descriptor.
+ *
+ * Corrections (Valery Fine 16/09/96):
+ *
+ *     It didn't work for C++ code with global variables and class definitions
+ *     The DumpExternalObject function has been introduced to generate .DEF
+ *file
+ *
+ * Author:   Valery Fine 16/09/96  (E-mail: fine@vxcern.cern.ch)
+ *----------------------------------------------------------------------
+ */
 #include "bindexplib.h"
 
 #include "cmsys/Encoding.hxx"
@@ -69,19 +70,19 @@
 #include <windows.h>
 
 #ifndef IMAGE_FILE_MACHINE_ARM
-#define IMAGE_FILE_MACHINE_ARM 0x01c0 // ARM Little-Endian
+#  define IMAGE_FILE_MACHINE_ARM 0x01c0 // ARM Little-Endian
 #endif
 
 #ifndef IMAGE_FILE_MACHINE_THUMB
-#define IMAGE_FILE_MACHINE_THUMB 0x01c2 // ARM Thumb/Thumb-2 Little-Endian
+#  define IMAGE_FILE_MACHINE_THUMB 0x01c2 // ARM Thumb/Thumb-2 Little-Endian
 #endif
 
 #ifndef IMAGE_FILE_MACHINE_ARMNT
-#define IMAGE_FILE_MACHINE_ARMNT 0x01c4 // ARM Thumb-2 Little-Endian
+#  define IMAGE_FILE_MACHINE_ARMNT 0x01c4 // ARM Thumb-2 Little-Endian
 #endif
 
 #ifndef IMAGE_FILE_MACHINE_ARM64
-#define IMAGE_FILE_MACHINE_ARM64 0xaa64 // ARM64 Little-Endian
+#  define IMAGE_FILE_MACHINE_ARM64 0xaa64 // ARM64 Little-Endian
 #endif
 
 typedef struct cmANON_OBJECT_HEADER_BIGOBJ
@@ -188,7 +189,7 @@ public:
   {
     this->ObjectImageHeader = ih;
     this->SymbolTable =
-      (SymbolTableType*)((DWORD_PTR) this->ObjectImageHeader +
+      (SymbolTableType*)((DWORD_PTR)this->ObjectImageHeader +
                          this->ObjectImageHeader->PointerToSymbolTable);
     this->SectionHeaders = GetSectionHeaderOffset(this->ObjectImageHeader);
     this->SymbolCount = this->ObjectImageHeader->NumberOfSymbols;
@@ -227,8 +228,8 @@ public:
           (pSymbolTable->Type == 0x20 || pSymbolTable->Type == 0x0)) {
         if (pSymbolTable->StorageClass == IMAGE_SYM_CLASS_EXTERNAL) {
           /*
-          *    The name of the Function entry points
-          */
+           *    The name of the Function entry points
+           */
           if (pSymbolTable->N.Name.Short != 0) {
             symbol.clear();
             symbol.insert(0, (const char*)pSymbolTable->N.ShortName, 8);
@@ -282,8 +283,8 @@ public:
       }
 
       /*
-      * Take into account any aux symbols
-      */
+       * Take into account any aux symbols
+       */
       i += pSymbolTable->NumberOfAuxSymbols;
       pSymbolTable += pSymbolTable->NumberOfAuxSymbols;
       pSymbolTable++;
@@ -345,11 +346,11 @@ bool DumpFile(const char* filename, std::set<std::string>& symbols,
          (imageHeader->Machine == IMAGE_FILE_MACHINE_ARM64)) &&
         (imageHeader->Characteristics == 0)) {
       /*
-      * The tests above are checking for IMAGE_FILE_HEADER.Machine
-      * if it contains supported machine formats (currently ARM and x86)
-      * and IMAGE_FILE_HEADER.Characteristics == 0 indicating that
-      * this is not linked COFF OBJ file;
-      */
+       * The tests above are checking for IMAGE_FILE_HEADER.Machine
+       * if it contains supported machine formats (currently ARM and x86)
+       * and IMAGE_FILE_HEADER.Characteristics == 0 indicating that
+       * this is not linked COFF OBJ file;
+       */
       DumpSymbols<IMAGE_FILE_HEADER, IMAGE_SYMBOL> symbolDumper(
         (PIMAGE_FILE_HEADER)lpFileBase, symbols, dataSymbols,
         (imageHeader->Machine == IMAGE_FILE_MACHINE_I386));
@@ -360,8 +361,8 @@ bool DumpFile(const char* filename, std::set<std::string>& symbols,
         (cmANON_OBJECT_HEADER_BIGOBJ*)lpFileBase;
       if (h->Sig1 == 0x0 && h->Sig2 == 0xffff) {
         DumpSymbols<cmANON_OBJECT_HEADER_BIGOBJ, cmIMAGE_SYMBOL_EX>
-        symbolDumper((cmANON_OBJECT_HEADER_BIGOBJ*)lpFileBase, symbols,
-                     dataSymbols, (h->Machine == IMAGE_FILE_MACHINE_I386));
+          symbolDumper((cmANON_OBJECT_HEADER_BIGOBJ*)lpFileBase, symbols,
+                       dataSymbols, (h->Machine == IMAGE_FILE_MACHINE_I386));
         symbolDumper.DumpObjFile();
       } else {
         printf("unrecognized file format in '%s'\n", filename);
@@ -389,7 +390,7 @@ bool bindexplib::AddDefinitionFile(const char* filename)
   }
   std::string str;
   while (std::getline(infile, str)) {
-    // skip the LIBRAY and EXPORTS lines (if any)
+    // skip the LIBRARY and EXPORTS lines (if any)
     if ((str.compare(0, 7, "LIBRARY") == 0) ||
         (str.compare(0, 7, "EXPORTS") == 0)) {
       continue;
diff --git a/Source/cmAddCompileDefinitionsCommand.cxx b/Source/cmAddCompileDefinitionsCommand.cxx
new file mode 100644
index 000000000..04748192a
--- /dev/null
+++ b/Source/cmAddCompileDefinitionsCommand.cxx
@@ -0,0 +1,20 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmAddCompileDefinitionsCommand.h"
+
+#include "cmMakefile.h"
+
+class cmExecutionStatus;
+
+bool cmAddCompileDefinitionsCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
+{
+  if (args.empty()) {
+    return true;
+  }
+
+  for (std::string const& i : args) {
+    this->Makefile->AddCompileDefinition(i);
+  }
+  return true;
+}
diff --git a/Source/cmAddCompileDefinitionsCommand.h b/Source/cmAddCompileDefinitionsCommand.h
new file mode 100644
index 000000000..e985dca8f
--- /dev/null
+++ b/Source/cmAddCompileDefinitionsCommand.h
@@ -0,0 +1,31 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmAddCompileDefinitionsCommand_h
+#define cmAddCompileDefinitionsCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+#include <vector>
+
+#include "cmCommand.h"
+
+class cmExecutionStatus;
+
+class cmAddCompileDefinitionsCommand : public cmCommand
+{
+public:
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override { return new cmAddCompileDefinitionsCommand; }
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) override;
+};
+
+#endif
diff --git a/Source/cmAddLibraryCommand.cxx b/Source/cmAddLibraryCommand.cxx
index 779223501..fae806324 100644
--- a/Source/cmAddLibraryCommand.cxx
+++ b/Source/cmAddLibraryCommand.cxx
@@ -211,8 +211,9 @@ bool cmAddLibraryCommand::InitialPass(std::vector<std::string> const& args,
     if (!aliasedTarget) {
       std::ostringstream e;
       e << "cannot create ALIAS target \"" << libName << "\" because target \""
-        << aliasedName << "\" does not already "
-                          "exist.";
+        << aliasedName
+        << "\" does not already "
+           "exist.";
       this->SetError(e.str());
       return false;
     }
diff --git a/Source/cmAffinity.cxx b/Source/cmAffinity.cxx
new file mode 100644
index 000000000..588b2f2f5
--- /dev/null
+++ b/Source/cmAffinity.cxx
@@ -0,0 +1,62 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmAffinity.h"
+
+#include "cm_uv.h"
+
+#ifndef CMAKE_USE_SYSTEM_LIBUV
+#  ifdef _WIN32
+#    define CM_HAVE_CPU_AFFINITY
+#    include <windows.h>
+#  elif defined(__linux__) || defined(__FreeBSD__)
+#    define CM_HAVE_CPU_AFFINITY
+#    include <pthread.h>
+#    include <sched.h>
+#    if defined(__FreeBSD__)
+#      include <pthread_np.h>
+#      include <sys/cpuset.h>
+#      include <sys/param.h>
+#    endif
+#    if defined(__linux__)
+typedef cpu_set_t cm_cpuset_t;
+#    else
+typedef cpuset_t cm_cpuset_t;
+#    endif
+#  endif
+#endif
+
+namespace cmAffinity {
+
+std::set<size_t> GetProcessorsAvailable()
+{
+  std::set<size_t> processorsAvailable;
+#ifdef CM_HAVE_CPU_AFFINITY
+  int cpumask_size = uv_cpumask_size();
+  if (cpumask_size > 0) {
+#  ifdef _WIN32
+    DWORD_PTR procmask;
+    DWORD_PTR sysmask;
+    if (GetProcessAffinityMask(GetCurrentProcess(), &procmask, &sysmask) !=
+        0) {
+      for (int i = 0; i < cpumask_size; ++i) {
+        if (procmask & (((DWORD_PTR)1) << i)) {
+          processorsAvailable.insert(i);
+        }
+      }
+    }
+#  else
+    cm_cpuset_t cpuset;
+    CPU_ZERO(&cpuset); // NOLINT(clang-tidy)
+    if (pthread_getaffinity_np(pthread_self(), sizeof(cpuset), &cpuset) == 0) {
+      for (int i = 0; i < cpumask_size; ++i) {
+        if (CPU_ISSET(i, &cpuset)) {
+          processorsAvailable.insert(i);
+        }
+      }
+    }
+#  endif
+  }
+#endif
+  return processorsAvailable;
+}
+}
diff --git a/Source/cmAffinity.h b/Source/cmAffinity.h
new file mode 100644
index 000000000..3775bae40
--- /dev/null
+++ b/Source/cmAffinity.h
@@ -0,0 +1,12 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#pragma once
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <cstddef>
+#include <set>
+
+namespace cmAffinity {
+
+std::set<size_t> GetProcessorsAvailable();
+}
diff --git a/Source/cmAlgorithms.h b/Source/cmAlgorithms.h
index 3380b78ca..bbd3e8ea4 100644
--- a/Source/cmAlgorithms.h
+++ b/Source/cmAlgorithms.h
@@ -13,6 +13,7 @@
 #include <sstream>
 #include <string.h>
 #include <string>
+#include <unordered_set>
 #include <utility>
 #include <vector>
 
@@ -275,55 +276,19 @@ typename Range::const_iterator cmRemoveMatching(Range& r, MatchRange const& m)
                         ContainerAlgorithms::BinarySearcher<MatchRange>(m));
 }
 
-namespace ContainerAlgorithms {
-
-template <typename Range, typename T = typename Range::value_type>
-struct RemoveDuplicatesAPI
-{
-  typedef typename Range::const_iterator const_iterator;
-  typedef typename Range::const_iterator value_type;
-
-  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 Range, typename T>
-struct RemoveDuplicatesAPI<Range, T*>
-{
-  typedef typename Range::const_iterator const_iterator;
-  typedef T* value_type;
-
-  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 Range>
 typename Range::const_iterator cmRemoveDuplicates(Range& r)
 {
-  typedef typename ContainerAlgorithms::RemoveDuplicatesAPI<Range> API;
-  typedef typename API::value_type T;
-  std::vector<T> unique;
-  unique.reserve(r.size());
+  typedef typename Range::value_type T;
+  std::unordered_set<T> unique;
   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)) {
-      unique.insert(low, API::uniqueValue(it));
+    const typename std::unordered_set<T>::iterator occur = unique.find(*it);
+    if (occur == unique.end()) {
+      unique.insert(*it);
     } else {
       indices.push_back(count);
     }
@@ -410,9 +375,9 @@ using std::size;
 
 // std::size backport from C++17.
 template <class C>
-#if !defined(_MSC_VER) || _MSC_VER >= 1900
+#  if !defined(_MSC_VER) || _MSC_VER >= 1900
 constexpr
-#endif
+#  endif
   auto
   size(C const& c) -> decltype(c.size())
 {
@@ -420,9 +385,9 @@ constexpr
 }
 
 template <typename T, size_t N>
-#if !defined(_MSC_VER) || _MSC_VER >= 1900
+#  if !defined(_MSC_VER) || _MSC_VER >= 1900
 constexpr
-#endif
+#  endif
   std::size_t
   size(const T (&)[N]) throw()
 {
@@ -440,22 +405,22 @@ using std::cend;
 
 // std::c{begin,end} backport from C++14
 template <class C>
-#if defined(_MSC_VER) && _MSC_VER < 1900
+#  if defined(_MSC_VER) && _MSC_VER < 1900
 auto cbegin(C const& c)
-#else
+#  else
 constexpr auto cbegin(C const& c) noexcept(noexcept(std::begin(c)))
-#endif
+#  endif
   -> decltype(std::begin(c))
 {
   return std::begin(c);
 }
 
 template <class C>
-#if defined(_MSC_VER) && _MSC_VER < 1900
+#  if defined(_MSC_VER) && _MSC_VER < 1900
 auto cend(C const& c)
-#else
+#  else
 constexpr auto cend(C const& c) noexcept(noexcept(std::end(c)))
-#endif
+#  endif
   -> decltype(std::end(c))
 {
   return std::end(c);
diff --git a/Source/cmArchiveWrite.cxx b/Source/cmArchiveWrite.cxx
index 02408a1e8..1dd773425 100644
--- a/Source/cmArchiveWrite.cxx
+++ b/Source/cmArchiveWrite.cxx
@@ -14,7 +14,7 @@
 #include <time.h>
 
 #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)
diff --git a/Source/cmArchiveWrite.h b/Source/cmArchiveWrite.h
index 56dce2a45..6c678acbe 100644
--- a/Source/cmArchiveWrite.h
+++ b/Source/cmArchiveWrite.h
@@ -10,7 +10,7 @@
 #include <string>
 
 #if !defined(CMAKE_BUILD_WITH_CMAKE)
-#error "cmArchiveWrite not allowed during bootstrap build!"
+#  error "cmArchiveWrite not allowed during bootstrap build!"
 #endif
 
 template <typename T>
@@ -28,6 +28,7 @@ public:
   void Clear() { this->IsValueSet = false; }
   bool IsSet() const { return this->IsValueSet; }
   T Get() const { return Value; }
+
 private:
   T Value;
   bool IsValueSet;
@@ -41,6 +42,7 @@ class cmArchiveWrite
 {
   typedef void (cmArchiveWrite::*safe_bool)();
   void safe_bool_true() {}
+
 public:
   /** Compression type.  */
   enum Compress
diff --git a/Source/cmCMakeHostSystemInformationCommand.cxx b/Source/cmCMakeHostSystemInformationCommand.cxx
index 662dd7421..882294264 100644
--- a/Source/cmCMakeHostSystemInformationCommand.cxx
+++ b/Source/cmCMakeHostSystemInformationCommand.cxx
@@ -8,12 +8,12 @@
 #include "cmsys/SystemInformation.hxx"
 
 #if defined(_WIN32)
-#include "cmAlgorithms.h"
-#include "cmGlobalGenerator.h"
-#include "cmGlobalVisualStudio15Generator.h"
-#include "cmSystemTools.h"
-#include "cmVSSetupHelper.h"
-#define HAVE_VS_SETUP_HELPER
+#  include "cmAlgorithms.h"
+#  include "cmGlobalGenerator.h"
+#  include "cmGlobalVisualStudio15Generator.h"
+#  include "cmSystemTools.h"
+#  include "cmVSSetupHelper.h"
+#  define HAVE_VS_SETUP_HELPER
 #endif
 
 class cmExecutionStatus;
diff --git a/Source/cmCMakeMinimumRequired.cxx b/Source/cmCMakeMinimumRequired.cxx
index bcc41fca9..2b51976b9 100644
--- a/Source/cmCMakeMinimumRequired.cxx
+++ b/Source/cmCMakeMinimumRequired.cxx
@@ -42,12 +42,27 @@ bool cmCMakeMinimumRequired::InitialPass(std::vector<std::string> const& args,
 
   // Make sure there was a version to check.
   if (version_string.empty()) {
-    return this->EnforceUnknownArguments();
+    return this->EnforceUnknownArguments(std::string());
+  }
+
+  // Separate the <min> version and any trailing ...<max> component.
+  std::string::size_type const dd = version_string.find("...");
+  std::string const version_min = version_string.substr(0, dd);
+  std::string const version_max = dd != std::string::npos
+    ? version_string.substr(dd + 3, std::string::npos)
+    : std::string();
+  if (dd != std::string::npos &&
+      (version_min.empty() || version_max.empty())) {
+    std::ostringstream e;
+    e << "VERSION \"" << version_string
+      << "\" does not have a version on both sides of \"...\".";
+    this->SetError(e.str());
+    return false;
   }
 
   // Save the required version string.
   this->Makefile->AddDefinition("CMAKE_MINIMUM_REQUIRED_VERSION",
-                                version_string.c_str());
+                                version_min.c_str());
 
   // Get the current version number.
   unsigned int current_major = cmVersion::GetMajorVersion();
@@ -61,10 +76,10 @@ bool cmCMakeMinimumRequired::InitialPass(std::vector<std::string> const& args,
   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,
+  if (sscanf(version_min.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 << "\".";
+    e << "could not parse VERSION \"" << version_min << "\".";
     this->SetError(e.str());
     return false;
   }
@@ -78,7 +93,7 @@ bool cmCMakeMinimumRequired::InitialPass(std::vector<std::string> const& args,
        current_patch == required_patch && current_tweak < required_tweak)) {
     // The current version is too low.
     std::ostringstream e;
-    e << "CMake " << version_string
+    e << "CMake " << version_min
       << " or higher is required.  You are running version "
       << cmVersion::GetCMakeVersion();
     this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
@@ -87,7 +102,7 @@ bool cmCMakeMinimumRequired::InitialPass(std::vector<std::string> const& args,
   }
 
   // The version is not from the future, so enforce unknown arguments.
-  if (!this->EnforceUnknownArguments()) {
+  if (!this->EnforceUnknownArguments(version_max)) {
     return false;
   }
 
@@ -95,22 +110,47 @@ bool cmCMakeMinimumRequired::InitialPass(std::vector<std::string> const& args,
     this->Makefile->IssueMessage(
       cmake::AUTHOR_WARNING,
       "Compatibility with CMake < 2.4 is not supported by CMake >= 3.0.");
-    this->Makefile->SetPolicyVersion("2.4");
+    this->Makefile->SetPolicyVersion("2.4", version_max);
   } else {
-    this->Makefile->SetPolicyVersion(version_string.c_str());
+    this->Makefile->SetPolicyVersion(version_min, version_max);
   }
 
   return true;
 }
 
-bool cmCMakeMinimumRequired::EnforceUnknownArguments()
+bool cmCMakeMinimumRequired::EnforceUnknownArguments(
+  std::string const& version_max)
 {
-  if (!this->UnknownArguments.empty()) {
-    std::ostringstream e;
-    e << "called with unknown argument \"" << this->UnknownArguments[0]
-      << "\".";
-    this->SetError(e.str());
-    return false;
+  if (this->UnknownArguments.empty()) {
+    return true;
   }
-  return true;
+
+  // Consider the max version if at least two components were given.
+  unsigned int max_major = 0;
+  unsigned int max_minor = 0;
+  unsigned int max_patch = 0;
+  unsigned int max_tweak = 0;
+  if (sscanf(version_max.c_str(), "%u.%u.%u.%u", &max_major, &max_minor,
+             &max_patch, &max_tweak) >= 2) {
+    unsigned int current_major = cmVersion::GetMajorVersion();
+    unsigned int current_minor = cmVersion::GetMinorVersion();
+    unsigned int current_patch = cmVersion::GetPatchVersion();
+    unsigned int current_tweak = cmVersion::GetTweakVersion();
+
+    if ((current_major < max_major) ||
+        (current_major == max_major && current_minor < max_minor) ||
+        (current_major == max_major && current_minor == max_minor &&
+         current_patch < max_patch) ||
+        (current_major == max_major && current_minor == max_minor &&
+         current_patch == max_patch && current_tweak < max_tweak)) {
+      // A ...<max> version was given that is larger than the current
+      // version of CMake, so tolerate unknown arguments.
+      return true;
+    }
+  }
+
+  std::ostringstream e;
+  e << "called with unknown argument \"" << this->UnknownArguments[0] << "\".";
+  this->SetError(e.str());
+  return false;
 }
diff --git a/Source/cmCMakeMinimumRequired.h b/Source/cmCMakeMinimumRequired.h
index 18d9460ed..f9b61e142 100644
--- a/Source/cmCMakeMinimumRequired.h
+++ b/Source/cmCMakeMinimumRequired.h
@@ -34,7 +34,7 @@ public:
 
 private:
   std::vector<std::string> UnknownArguments;
-  bool EnforceUnknownArguments();
+  bool EnforceUnknownArguments(std::string const& version_max);
 };
 
 #endif
diff --git a/Source/cmCMakePolicyCommand.cxx b/Source/cmCMakePolicyCommand.cxx
index 3ccc815e6..adf9ef80e 100644
--- a/Source/cmCMakePolicyCommand.cxx
+++ b/Source/cmCMakePolicyCommand.cxx
@@ -95,7 +95,11 @@ bool cmCMakePolicyCommand::HandleSetMode(std::vector<std::string> const& args)
 
 bool cmCMakePolicyCommand::HandleGetMode(std::vector<std::string> const& args)
 {
-  if (args.size() != 3) {
+  bool parent_scope = false;
+  if (args.size() == 4 && args[3] == "PARENT_SCOPE") {
+    // Undocumented PARENT_SCOPE option for use within CMake.
+    parent_scope = true;
+  } else if (args.size() != 3) {
     this->SetError("GET must be given exactly 2 additional arguments.");
     return false;
   }
@@ -115,7 +119,8 @@ bool cmCMakePolicyCommand::HandleGetMode(std::vector<std::string> const& args)
   }
 
   // Lookup the policy setting.
-  cmPolicies::PolicyStatus status = this->Makefile->GetPolicyStatus(pid);
+  cmPolicies::PolicyStatus status =
+    this->Makefile->GetPolicyStatus(pid, parent_scope);
   switch (status) {
     case cmPolicies::OLD:
       // Report that the policy is set to OLD.
@@ -156,6 +161,23 @@ bool cmCMakePolicyCommand::HandleVersionMode(
     this->SetError("VERSION given too many arguments");
     return false;
   }
-  this->Makefile->SetPolicyVersion(args[1].c_str());
+  std::string const& version_string = args[1];
+
+  // Separate the <min> version and any trailing ...<max> component.
+  std::string::size_type const dd = version_string.find("...");
+  std::string const version_min = version_string.substr(0, dd);
+  std::string const version_max = dd != std::string::npos
+    ? version_string.substr(dd + 3, std::string::npos)
+    : std::string();
+  if (dd != std::string::npos &&
+      (version_min.empty() || version_max.empty())) {
+    std::ostringstream e;
+    e << "VERSION \"" << version_string
+      << "\" does not have a version on both sides of \"...\".";
+    this->SetError(e.str());
+    return false;
+  }
+
+  this->Makefile->SetPolicyVersion(version_min, version_max);
   return true;
 }
diff --git a/Source/cmCPluginAPI.cxx b/Source/cmCPluginAPI.cxx
index 1ec76acf2..be3d2f45e 100644
--- a/Source/cmCPluginAPI.cxx
+++ b/Source/cmCPluginAPI.cxx
@@ -17,7 +17,7 @@
 #include <stdlib.h>
 
 #ifdef __QNX__
-#include <malloc.h> /* for malloc/free on QNX */
+#  include <malloc.h> /* for malloc/free on QNX */
 #endif
 
 extern "C" {
@@ -395,9 +395,10 @@ void CCONV cmAddLibrary(void* arg, const char* libname, int shared,
   for (i = 0; i < numSrcs; ++i) {
     srcs2.push_back(srcs[i]);
   }
-  mf->AddLibrary(libname, (shared ? cmStateEnums::SHARED_LIBRARY
-                                  : cmStateEnums::STATIC_LIBRARY),
-                 srcs2);
+  mf->AddLibrary(
+    libname,
+    (shared ? cmStateEnums::SHARED_LIBRARY : cmStateEnums::STATIC_LIBRARY),
+    srcs2);
 }
 
 char CCONV* cmExpandVariablesInString(void* arg, const char* source,
@@ -405,7 +406,8 @@ char CCONV* cmExpandVariablesInString(void* arg, const char* source,
 {
   cmMakefile* mf = static_cast<cmMakefile*>(arg);
   std::string barf = source;
-  std::string result = mf->ExpandVariablesInString(barf, escapeQuotes, atOnly);
+  std::string const& result =
+    mf->ExpandVariablesInString(barf, escapeQuotes, atOnly);
   return strdup(result.c_str());
 }
 
@@ -664,7 +666,7 @@ 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)) {
     sf->SourceName = cmSystemTools::GetFilenamePath(name);
     if (!sf->SourceName.empty()) {
       sf->SourceName += "/";
@@ -691,7 +693,7 @@ void CCONV cmSourceFileSetName(void* arg, const char* name, const char* dir,
     hname = pathname;
     hname += ".";
     hname += *ext;
-    if (cmSystemTools::FileExists(hname.c_str())) {
+    if (cmSystemTools::FileExists(hname)) {
       sf->SourceExtension = *ext;
       sf->FullPath = hname;
       return;
@@ -704,7 +706,7 @@ void CCONV cmSourceFileSetName(void* arg, const char* name, const char* dir,
     hname = pathname;
     hname += ".";
     hname += *ext;
-    if (cmSystemTools::FileExists(hname.c_str())) {
+    if (cmSystemTools::FileExists(hname)) {
       sf->SourceExtension = *ext;
       sf->FullPath = hname;
       return;
diff --git a/Source/cmCPluginAPI.h b/Source/cmCPluginAPI.h
index 88b81c6c1..adc57a202 100644
--- a/Source/cmCPluginAPI.h
+++ b/Source/cmCPluginAPI.h
@@ -19,9 +19,9 @@ extern "C" {
 #endif
 
 #ifdef __WATCOMC__
-#define CCONV __cdecl
+#  define CCONV __cdecl
 #else
-#define CCONV
+#  define CCONV
 #endif
 /*=========================================================================
 this is the structure of function entry points that a plugin may call. This
@@ -161,9 +161,9 @@ typedef struct
 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
+#  define CM_PLUGIN_EXPORT
 #endif
 
 /*=========================================================================
diff --git a/Source/cmCTest.cxx b/Source/cmCTest.cxx
index 3fccc386a..d0e668d4d 100644
--- a/Source/cmCTest.cxx
+++ b/Source/cmCTest.cxx
@@ -55,7 +55,7 @@
 #include "cmake.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                                                              \
@@ -75,9 +75,10 @@ struct tm* cmCTest::GetNightlyTime(std::string const& str, bool tomorrowtag)
   // 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);
+  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
@@ -99,16 +100,17 @@ struct tm* cmCTest::GetNightlyTime(std::string const& str, bool tomorrowtag)
     // time of the current open dashboard
     ntime -= dayLength;
     cmCTestLog(this, DEBUG, "Pick yesterday" << std::endl);
-    cmCTestLog(this, DEBUG, "   Future time, subtract day: " << ntime
-                                                             << std::endl);
+    cmCTestLog(this, DEBUG,
+               "   Future time, subtract day: " << ntime << 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);
+  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;
@@ -390,13 +392,14 @@ int cmCTest::Initialize(const char* binary_dir, cmCTestStartCommand* command)
   cmCTestOptionalLog(this, DEBUG, "Here: " << __LINE__ << std::endl, quiet);
   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()) {
@@ -431,16 +434,16 @@ int cmCTest::Initialize(const char* binary_dir, cmCTestStartCommand* command)
     std::string testingDir = this->BinaryDir + "/Testing";
     if (cmSystemTools::FileExists(testingDir)) {
       if (!cmSystemTools::FileIsDirectory(testingDir)) {
-        cmCTestLog(this, ERROR_MESSAGE, "File "
-                     << testingDir
-                     << " is in the place of the testing directory"
-                     << std::endl);
+        cmCTestLog(this, ERROR_MESSAGE,
+                   "File " << testingDir
+                           << " is in the place of the testing directory"
+                           << std::endl);
         return 0;
       }
     } else {
       if (!cmSystemTools::MakeDirectory(testingDir)) {
-        cmCTestLog(this, ERROR_MESSAGE, "Cannot create directory "
-                     << testingDir << std::endl);
+        cmCTestLog(this, ERROR_MESSAGE,
+                   "Cannot create directory " << testingDir << std::endl);
         return 0;
       }
     }
@@ -474,11 +477,13 @@ int cmCTest::Initialize(const char* binary_dir, cmCTestStartCommand* command)
             day != lctime->tm_mday) {
           tag.clear();
         }
-        std::string tagmode;
-        if (cmSystemTools::GetLineFromStream(tfin, tagmode)) {
-          if (tagmode.size() > 4 && !this->Parts[PartStart]) {
-            this->TestModel = cmCTest::GetTestModelFromString(tagmode.c_str());
-          }
+        std::string track;
+        if (cmSystemTools::GetLineFromStream(tfin, track)) {
+          this->SpecificTrack = track;
+        }
+        std::string model;
+        if (cmSystemTools::GetLineFromStream(tfin, model)) {
+          this->TestModel = GetTestModelFromString(model.c_str());
         }
         tfin.close();
       }
@@ -502,30 +507,83 @@ int cmCTest::Initialize(const char* binary_dir, cmCTestStartCommand* command)
         if (ofs) {
           ofs << tag << std::endl;
           ofs << this->GetTestModelString() << std::endl;
+          switch (this->TestModel) {
+            case cmCTest::EXPERIMENTAL:
+              ofs << "Experimental" << std::endl;
+              break;
+            case cmCTest::NIGHTLY:
+              ofs << "Nightly" << std::endl;
+              break;
+            case cmCTest::CONTINUOUS:
+              ofs << "Continuous" << std::endl;
+              break;
+          }
         }
         ofs.close();
         if (nullptr == command) {
-          cmCTestOptionalLog(this, OUTPUT, "Create new tag: "
-                               << tag << " - " << this->GetTestModelString()
-                               << std::endl,
+          cmCTestOptionalLog(this, OUTPUT,
+                             "Create new tag: " << tag << " - "
+                                                << this->GetTestModelString()
+                                                << std::endl,
                              quiet);
         }
       }
     } else {
+      std::string track;
+      std::string modelStr;
+      int model = cmCTest::UNKNOWN;
+
       if (tfin) {
         cmSystemTools::GetLineFromStream(tfin, tag);
+        cmSystemTools::GetLineFromStream(tfin, track);
+        if (cmSystemTools::GetLineFromStream(tfin, modelStr)) {
+          model = GetTestModelFromString(modelStr.c_str());
+        }
         tfin.close();
       }
 
       if (tag.empty()) {
-        cmCTestLog(this, ERROR_MESSAGE, "Cannot read existing TAG file in "
-                     << testingDir << std::endl);
+        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,
+      if (this->TestModel == cmCTest::UNKNOWN) {
+        if (model == cmCTest::UNKNOWN) {
+          cmCTestLog(this, ERROR_MESSAGE,
+                     "TAG file does not contain model and "
+                     "no model specified in start command"
+                       << std::endl);
+          return 0;
+        }
+
+        this->SetTestModel(model);
+      }
+
+      if (model != this->TestModel && model != cmCTest::UNKNOWN &&
+          this->TestModel != cmCTest::UNKNOWN) {
+        cmCTestOptionalLog(this, WARNING,
+                           "Model given in TAG does not match "
+                           "model given in ctest_start()"
+                             << std::endl,
+                           quiet);
+      }
+
+      if (!this->SpecificTrack.empty() && track != this->SpecificTrack) {
+        cmCTestOptionalLog(this, WARNING,
+                           "Track given in TAG does not match "
+                           "track given in ctest_start()"
+                             << std::endl,
+                           quiet);
+      } else {
+        this->SpecificTrack = track;
+      }
+
+      cmCTestOptionalLog(this, OUTPUT,
+                         "  Use existing tag: " << tag << " - "
+                                                << this->GetTestModelString()
+                                                << std::endl,
                          quiet);
     }
 
@@ -563,8 +621,9 @@ bool cmCTest::InitializeFromCommand(cmCTestStartCommand* command)
   }
 
   if (!fname.empty()) {
-    cmCTestOptionalLog(this, OUTPUT, "   Reading ctest configuration file: "
-                         << fname << std::endl,
+    cmCTestOptionalLog(this, OUTPUT,
+                       "   Reading ctest configuration file: " << fname
+                                                               << std::endl,
                        command->ShouldBeQuiet());
     bool readit = mf->ReadDependentFile(fname.c_str());
     if (!readit) {
@@ -579,7 +638,8 @@ bool cmCTest::InitializeFromCommand(cmCTestStartCommand* command)
                          << bld_dir_fname << std::endl,
                        command->ShouldBeQuiet());
     cmCTestOptionalLog(
-      this, WARNING, "Cannot locate CTest configuration: in SourceDirectory: "
+      this, WARNING,
+      "Cannot locate CTest configuration: in SourceDirectory: "
         << src_dir_fname << std::endl,
       command->ShouldBeQuiet());
   }
@@ -595,7 +655,8 @@ bool cmCTest::InitializeFromCommand(cmCTestStartCommand* command)
   if (dartVersion) {
     this->DartVersion = atoi(dartVersion);
     if (this->DartVersion < 0) {
-      cmCTestLog(this, ERROR_MESSAGE, "Invalid Dart server version: "
+      cmCTestLog(this, ERROR_MESSAGE,
+                 "Invalid Dart server version: "
                    << dartVersion << ". Please specify the version number."
                    << std::endl);
       return false;
@@ -606,9 +667,9 @@ bool cmCTest::InitializeFromCommand(cmCTestStartCommand* command)
   if (!this->Initialize(bld_dir.c_str(), command)) {
     return false;
   }
-  cmCTestOptionalLog(this, OUTPUT, "   Use "
-                       << this->GetTestModelString()
-                       << " tag: " << this->GetCurrentTag() << std::endl,
+  cmCTestOptionalLog(this, OUTPUT,
+                     "   Use " << this->GetTestModelString() << " tag: "
+                               << this->GetCurrentTag() << std::endl,
                      command->ShouldBeQuiet());
   return true;
 }
@@ -627,13 +688,13 @@ bool cmCTest::UpdateCTestConfiguration()
   if (!cmSystemTools::FileExists(fileName)) {
     // No need to exit if we are not producing XML
     if (this->ProduceXML) {
-      cmCTestLog(this, ERROR_MESSAGE, "Cannot find file: " << fileName
-                                                           << std::endl);
+      cmCTestLog(this, ERROR_MESSAGE,
+                 "Cannot find file: " << fileName << std::endl);
       return false;
     }
   } else {
-    cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, "Parse Config file:" << fileName
-                                                                  << "\n");
+    cmCTestLog(this, HANDLER_VERBOSE_OUTPUT,
+               "Parse Config file:" << fileName << "\n");
     // parse the dart test file
     cmsys::ifstream fin(fileName.c_str());
 
@@ -724,8 +785,9 @@ bool cmCTest::SetTest(const char* ttype, bool report)
     return true;
   }
   if (report) {
-    cmCTestLog(this, ERROR_MESSAGE, "Don't know about test \""
-                 << ttype << "\" yet..." << std::endl);
+    cmCTestLog(this, ERROR_MESSAGE,
+               "Don't know about test \"" << ttype << "\" yet..."
+                                          << std::endl);
   }
   return false;
 }
@@ -743,23 +805,24 @@ bool cmCTest::OpenOutputFile(const std::string& path, const std::string& name,
   }
   if (cmSystemTools::FileExists(testingDir)) {
     if (!cmSystemTools::FileIsDirectory(testingDir)) {
-      cmCTestLog(this, ERROR_MESSAGE, "File "
-                   << testingDir << " is in the place of the testing directory"
-                   << std::endl);
+      cmCTestLog(this, ERROR_MESSAGE,
+                 "File " << testingDir
+                         << " is in the place of the testing directory"
+                         << std::endl);
       return false;
     }
   } else {
     if (!cmSystemTools::MakeDirectory(testingDir)) {
-      cmCTestLog(this, ERROR_MESSAGE, "Cannot create directory " << testingDir
-                                                                 << std::endl);
+      cmCTestLog(this, ERROR_MESSAGE,
+                 "Cannot create directory " << testingDir << std::endl);
       return false;
     }
   }
   std::string filename = testingDir + "/" + name;
   stream.Open(filename.c_str());
   if (!stream) {
-    cmCTestLog(this, ERROR_MESSAGE, "Problem opening file: " << filename
-                                                             << std::endl);
+    cmCTestLog(this, ERROR_MESSAGE,
+               "Problem opening file: " << filename << std::endl);
     return false;
   }
   if (compress) {
@@ -998,9 +1061,10 @@ int cmCTest::RunMakeCommand(const char* command, std::string& output,
   int length;
   cmProcessOutput processOutput(encoding);
   std::string strdata;
-  cmCTestLog(this, HANDLER_PROGRESS_OUTPUT, "   Each . represents "
-               << tick_len << " bytes of output" << std::endl
-               << "    " << std::flush);
+  cmCTestLog(this, HANDLER_PROGRESS_OUTPUT,
+             "   Each . represents " << tick_len << " bytes of output"
+                                     << std::endl
+                                     << "    " << std::flush);
   while (cmsysProcess_WaitForData(cp, &data, &length, nullptr)) {
     processOutput.DecodeText(data, length, strdata);
     for (char& cc : strdata) {
@@ -1034,8 +1098,9 @@ int cmCTest::RunMakeCommand(const char* command, std::string& output,
       ofs << cmCTestLogWrite(strdata.c_str(), strdata.size());
     }
   }
-  cmCTestLog(this, HANDLER_PROGRESS_OUTPUT, " Size of output: "
-               << int(double(output.size()) / 1024.0) << "K" << std::endl);
+  cmCTestLog(this, HANDLER_PROGRESS_OUTPUT,
+             " Size of output: " << int(double(output.size()) / 1024.0) << "K"
+                                 << std::endl);
 
   cmsysProcess_WaitForExit(cp, nullptr);
 
@@ -1047,16 +1112,17 @@ int cmCTest::RunMakeCommand(const char* command, std::string& 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);
+    cmCTestLog(this, WARNING,
+               "There was an exception: " << *retVal << std::endl);
   } else if (result == cmsysProcess_State_Expired) {
     cmCTestLog(this, WARNING, "There was a timeout" << std::endl);
   } 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);
+    cmCTestLog(this, ERROR_MESSAGE,
+               "There was an error: " << cmsysProcess_GetErrorString(cp)
+                                      << std::endl);
   }
 
   cmsysProcess_Delete(cp);
@@ -1092,7 +1158,8 @@ int cmCTest::RunTest(std::vector<const char*> argv, std::string* output,
   if (timeout <= cmDuration::zero()) {
     timeout = std::chrono::seconds(1);
   }
-  cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, "Test timeout computed to be: "
+  cmCTestLog(this, HANDLER_VERBOSE_OUTPUT,
+             "Test timeout computed to be: "
                << (timeout == cmCTest::MaxDuration()
                      ? std::string("infinite")
                      : std::to_string(cmDurationTo<unsigned int>(timeout)))
@@ -1200,8 +1267,8 @@ int cmCTest::RunTest(std::vector<const char*> argv, std::string* output,
   if (output && tempOutput.begin() != tempOutput.end()) {
     output->append(&*tempOutput.begin(), tempOutput.size());
   }
-  cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, "-- Process completed"
-               << std::endl);
+  cmCTestLog(this, HANDLER_VERBOSE_OUTPUT,
+             "-- Process completed" << std::endl);
 
   int result = cmsysProcess_GetState(cp);
 
@@ -1220,16 +1287,18 @@ int cmCTest::RunTest(std::vector<const char*> argv, std::string* output,
     if (output) {
       *output += outerr;
     }
-    cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, outerr << std::endl
-                                                    << std::flush);
+    cmCTestLog(this, HANDLER_VERBOSE_OUTPUT,
+               outerr << std::endl
+                      << std::flush);
   } else if (result == cmsysProcess_State_Error) {
     std::string outerr = "\n*** ERROR executing: ";
     outerr += cmsysProcess_GetErrorString(cp);
     if (output) {
       *output += outerr;
     }
-    cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, outerr << std::endl
-                                                    << std::flush);
+    cmCTestLog(this, HANDLER_VERBOSE_OUTPUT,
+               outerr << std::endl
+                      << std::flush);
   }
   cmsysProcess_Delete(cp);
 
@@ -1269,8 +1338,9 @@ std::string cmCTest::SafeBuildIdField(const std::string& value)
 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."
+    cmCTestLog(this, ERROR_MESSAGE,
+               "Current Tag empty, this may mean"
+               " NightlStartTime was not set correctly."
                  << std::endl);
     cmSystemTools::SetFatalErrorOccured();
   }
@@ -1439,8 +1509,9 @@ int cmCTest::GenerateCTestNotesOutput(cmXMLWriter& xml,
       ifs.close();
     } else {
       xml.Content("Problem reading file: " + file + "\n");
-      cmCTestLog(this, ERROR_MESSAGE, "Problem reading file: "
-                   << file << " while creating notes" << std::endl);
+      cmCTestLog(this, ERROR_MESSAGE,
+                 "Problem reading file: " << file << " while creating notes"
+                                          << std::endl);
     }
     xml.EndElement(); // Text
     xml.EndElement(); // Note
@@ -1489,8 +1560,9 @@ std::string cmCTest::Base64GzipEncodeFile(std::string const& file)
 
   if (!cmSystemTools::CreateTar(tarFile.c_str(), files,
                                 cmSystemTools::TarCompressGZip, false)) {
-    cmCTestLog(this, ERROR_MESSAGE, "Error creating tar while "
-                                    "encoding file: "
+    cmCTestLog(this, ERROR_MESSAGE,
+               "Error creating tar while "
+               "encoding file: "
                  << file << std::endl);
     return "";
   }
@@ -1502,11 +1574,12 @@ std::string cmCTest::Base64GzipEncodeFile(std::string const& file)
 std::string cmCTest::Base64EncodeFile(std::string const& file)
 {
   size_t const len = cmSystemTools::FileLength(file);
-  cmsys::ifstream ifs(file.c_str(), std::ios::in
+  cmsys::ifstream ifs(file.c_str(),
+                      std::ios::in
 #ifdef _WIN32
                         | std::ios::binary
 #endif
-                      );
+  );
   std::vector<char> file_buffer(len + 1);
   ifs.read(&file_buffer[0], len);
   ifs.close();
@@ -1524,8 +1597,9 @@ bool cmCTest::SubmitExtraFiles(const VectorOfStrings& files)
 {
   for (cmsys::String const& file : files) {
     if (!cmSystemTools::FileExists(file)) {
-      cmCTestLog(this, ERROR_MESSAGE, "Cannot find extra file: "
-                   << file << " to submit." << std::endl;);
+      cmCTestLog(this, ERROR_MESSAGE,
+                 "Cannot find extra file: " << file << " to submit."
+                                            << std::endl;);
       return false;
     }
     this->AddSubmitFile(PartExtraFiles, file.c_str());
@@ -1682,7 +1756,8 @@ void cmCTest::ErrorMessageUnknownDashDValue(std::string& val)
              "CTest -D called with incorrect option: " << val << std::endl);
 
   cmCTestLog(
-    this, ERROR_MESSAGE, "Available options are:"
+    this, ERROR_MESSAGE,
+    "Available options are:"
       << std::endl
       << "  ctest -D Continuous" << std::endl
       << "  ctest -D Continuous(Start|Update|Configure|Build)" << std::endl
@@ -2141,9 +2216,11 @@ bool cmCTest::HandleTestActionArgument(const char* ctestExec, size_t& i,
     i++;
     if (!this->SetTest(args[i].c_str(), false)) {
       success = false;
-      cmCTestLog(this, ERROR_MESSAGE, "CTest -T called with incorrect option: "
-                   << args[i] << std::endl);
-      cmCTestLog(this, ERROR_MESSAGE, "Available options are:"
+      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
@@ -2177,9 +2254,11 @@ bool cmCTest::HandleTestModelArgument(const char* ctestExec, size_t& i,
       this->SetTestModel(cmCTest::EXPERIMENTAL);
     } else {
       success = false;
-      cmCTestLog(this, ERROR_MESSAGE, "CTest -M called with incorrect option: "
-                   << str << std::endl);
-      cmCTestLog(this, ERROR_MESSAGE, "Available options are:"
+      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
@@ -2220,8 +2299,8 @@ int cmCTest::ExecuteTests()
     std::string cwd = cmSystemTools::GetCurrentWorkingDirectory();
     if (!this->Initialize(cwd.c_str(), nullptr)) {
       res = 12;
-      cmCTestLog(this, ERROR_MESSAGE, "Problem initializing the dashboard."
-                   << std::endl);
+      cmCTestLog(this, ERROR_MESSAGE,
+                 "Problem initializing the dashboard." << std::endl);
     } else {
       res = this->ProcessSteps();
     }
@@ -2245,8 +2324,8 @@ int cmCTest::RunCMakeAndTest(std::string* output)
   cmDynamicLoader::FlushCache();
 #endif
   if (retv != 0) {
-    cmCTestLog(this, DEBUG, "build and test failing returning: " << retv
-                                                                 << std::endl);
+    cmCTestLog(this, DEBUG,
+               "build and test failing returning: " << retv << std::endl);
   }
   return retv;
 }
@@ -2301,22 +2380,25 @@ int cmCTest::ReadCustomConfigurationFileTree(const char* dir, cmMakefile* mf)
   bool found = false;
   VectorOfStrings dirs;
   VectorOfStrings ndirs;
-  cmCTestLog(this, DEBUG, "* Read custom CTest configuration directory: "
-               << dir << std::endl);
+  cmCTestLog(this, DEBUG,
+             "* Read custom CTest configuration directory: " << dir
+                                                             << std::endl);
 
   std::string fname = dir;
   fname += "/CTestCustom.cmake";
   cmCTestLog(this, DEBUG, "* Check for file: " << fname << std::endl);
   if (cmSystemTools::FileExists(fname)) {
-    cmCTestLog(this, DEBUG, "* Read custom CTest configuration file: "
-                 << fname << std::endl);
+    cmCTestLog(this, DEBUG,
+               "* Read custom CTest configuration file: " << 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);
+      cmCTestLog(this, ERROR_MESSAGE,
+                 "Problem reading custom configuration: " << fname
+                                                          << std::endl);
     }
     found = true;
     if (erroroc) {
@@ -2334,8 +2416,9 @@ int cmCTest::ReadCustomConfigurationFileTree(const char* dir, cmMakefile* mf)
     std::vector<std::string>& files = gl.GetFiles();
     std::vector<std::string>::iterator fileIt;
     for (fileIt = files.begin(); fileIt != files.end(); ++fileIt) {
-      cmCTestLog(this, DEBUG, "* Read custom CTest configuration file: "
-                   << *fileIt << std::endl);
+      cmCTestLog(this, DEBUG,
+                 "* Read custom CTest configuration file: " << *fileIt
+                                                            << std::endl);
       if (!mf->ReadListFile(fileIt->c_str()) ||
           cmSystemTools::GetErrorOccuredFlag()) {
         cmCTestLog(this, ERROR_MESSAGE,
@@ -2348,9 +2431,10 @@ int cmCTest::ReadCustomConfigurationFileTree(const char* dir, cmMakefile* mf)
 
   if (found) {
     for (auto& handler : this->TestingHandlers) {
-      cmCTestLog(
-        this, DEBUG, "* Read custom CTest configuration vectors for handler: "
-          << handler.first << " (" << handler.second << ")" << std::endl);
+      cmCTestLog(this, DEBUG,
+                 "* Read custom CTest configuration vectors for handler: "
+                   << handler.first << " (" << handler.second << ")"
+                   << std::endl);
       handler.second->PopulateCustomVectors(mf);
     }
   }
@@ -2452,7 +2536,8 @@ void cmCTest::EmptyCTestConfiguration()
 void cmCTest::SetCTestConfiguration(const char* name, const char* value,
                                     bool suppress)
 {
-  cmCTestOptionalLog(this, HANDLER_VERBOSE_OUTPUT, "SetCTestConfiguration:"
+  cmCTestOptionalLog(this, HANDLER_VERBOSE_OUTPUT,
+                     "SetCTestConfiguration:"
                        << name << ":" << (value ? value : "(null)") << "\n",
                      suppress);
 
@@ -2839,8 +2924,8 @@ bool cmCTest::CompressString(std::string& str)
   ret = deflate(&strm, Z_FINISH);
 
   if (ret != Z_STREAM_END) {
-    cmCTestLog(this, ERROR_MESSAGE, "Error during gzip compression."
-                 << std::endl);
+    cmCTestLog(this, ERROR_MESSAGE,
+               "Error during gzip compression." << std::endl);
     return false;
   }
 
diff --git a/Source/cmCTest.h b/Source/cmCTest.h
index 673a40e5f..ddeab1a8c 100644
--- a/Source/cmCTest.h
+++ b/Source/cmCTest.h
@@ -139,7 +139,7 @@ public:
    */
   int TestDirectory(bool memcheck);
 
-  /** what is the configuraiton type, e.g. Debug, Release etc. */
+  /** what is the configuration type, e.g. Debug, Release etc. */
   std::string const& GetConfigType();
   cmDuration GetTimeOut() { return this->TimeOut; }
   void SetTimeOut(cmDuration t) { this->TimeOut = t; }
@@ -295,9 +295,10 @@ public:
 
   enum
   {
-    EXPERIMENTAL,
-    NIGHTLY,
-    CONTINUOUS
+    UNKNOWN = -1,
+    EXPERIMENTAL = 0,
+    NIGHTLY = 1,
+    CONTINUOUS = 2,
   };
 
   /** provide some more detailed info on the return code for ctest */
@@ -347,7 +348,7 @@ public:
                                               const std::string& cmake_var,
                                               bool suppress = false);
 
-  /** Make string safe to be send as an URL */
+  /** Make string safe to be sent as a URL */
   static std::string MakeURLSafe(const std::string&);
 
   /** Decode a URL to the original string.  */
@@ -560,7 +561,7 @@ private:
   bool HandleCommandLineArguments(size_t& i, std::vector<std::string>& args,
                                   std::string& errormsg);
 
-  /** hande the -S -SP and -SR arguments */
+  /** handle the -S -SP and -SR arguments */
   void HandleScriptArguments(size_t& i, std::vector<std::string>& args,
                              bool& SRArgumentSpecified);
 
diff --git a/Source/cmCacheManager.cxx b/Source/cmCacheManager.cxx
index fab2445ac..c6a1cff92 100644
--- a/Source/cmCacheManager.cxx
+++ b/Source/cmCacheManager.cxx
@@ -8,6 +8,7 @@
 #include <sstream>
 #include <stdio.h>
 #include <string.h>
+#include <string>
 
 #include "cmGeneratedFileStream.h"
 #include "cmMessenger.h"
@@ -160,14 +161,14 @@ bool cmCacheManager::LoadCache(const std::string& path, bool internal,
     currentcwd += "/CMakeCache.txt";
     oldcwd += "/CMakeCache.txt";
     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(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());
+      std::ostringstream message;
+      message << "The current CMakeCache.txt directory " << currentcwd
+              << " is different than the directory "
+              << this->GetInitializedCacheValue("CMAKE_CACHEFILE_DIR")
+              << " 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.str().c_str());
     }
   }
   return true;
@@ -243,19 +244,18 @@ bool cmCacheManager::SaveCache(const std::string& path, cmMessenger* messenger)
   }
   // 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 "
+  this->AddCacheEntry("CMAKE_CACHE_MAJOR_VERSION",
+                      std::to_string(cmVersion::GetMajorVersion()).c_str(),
+                      "Major version of cmake used to create the "
                       "current loaded cache",
                       cmStateEnums::INTERNAL);
-  sprintf(temp, "%d", cmVersion::GetMajorVersion());
-  this->AddCacheEntry("CMAKE_CACHE_MAJOR_VERSION", temp,
-                      "Major version of cmake used to create the "
+  this->AddCacheEntry("CMAKE_CACHE_MINOR_VERSION",
+                      std::to_string(cmVersion::GetMinorVersion()).c_str(),
+                      "Minor version of cmake used to create the "
                       "current loaded cache",
                       cmStateEnums::INTERNAL);
-  sprintf(temp, "%d", cmVersion::GetPatchVersion());
-  this->AddCacheEntry("CMAKE_CACHE_PATCH_VERSION", temp,
+  this->AddCacheEntry("CMAKE_CACHE_PATCH_VERSION",
+                      std::to_string(cmVersion::GetPatchVersion()).c_str(),
                       "Patch version of cmake used to create the "
                       "current loaded cache",
                       cmStateEnums::INTERNAL);
@@ -566,7 +566,8 @@ void cmCacheManager::AddCacheEntry(const std::string& key, const char* value,
       cmSystemTools::ConvertToUnixSlashes(e.Value);
     }
   }
-  e.SetProperty("HELPSTRING", helpString
+  e.SetProperty("HELPSTRING",
+                helpString
                   ? helpString
                   : "(This variable does not exist and should not be used)");
 }
diff --git a/Source/cmCallVisualStudioMacro.cxx b/Source/cmCallVisualStudioMacro.cxx
index 99fe5877e..ecfcfb965 100644
--- a/Source/cmCallVisualStudioMacro.cxx
+++ b/Source/cmCallVisualStudioMacro.cxx
@@ -7,7 +7,7 @@
 #include "cmSystemTools.h"
 
 #if defined(_MSC_VER)
-#define HAVE_COMDEF_H
+#  define HAVE_COMDEF_H
 #endif
 
 // Just for this file:
@@ -16,39 +16,39 @@ static bool LogErrorsAsMessages;
 
 #if defined(HAVE_COMDEF_H)
 
-#include <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
-#else
-#ifdef _DEBUG
-#pragma comment(lib, "comsuppd.lib")
-#else
-#pragma comment(lib, "comsupp.lib")
-#endif
-#endif
+#  ifdef _NATIVE_WCHAR_T_DEFINED
+#    ifdef _DEBUG
+#      pragma comment(lib, "comsuppwd.lib")
+#    else
+#      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,
diff --git a/Source/cmCommandArgumentsHelper.h b/Source/cmCommandArgumentsHelper.h
index d3f102c29..c68e64c10 100644
--- a/Source/cmCommandArgumentsHelper.h
+++ b/Source/cmCommandArgumentsHelper.h
@@ -98,6 +98,7 @@ public:
   /** 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;
@@ -118,6 +119,7 @@ public:
   /// 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;
@@ -136,6 +138,7 @@ public:
 
   /// Has it been enabled ?
   bool IsEnabled() const { return this->Enabled; }
+
 private:
   bool Enabled;
   bool DoConsume(const std::string& arg, unsigned int index) override;
@@ -153,6 +156,7 @@ public:
 
   /// Is it still enabled ?
   bool IsEnabled() const { return this->Enabled; }
+
 private:
   bool Enabled;
   bool DoConsume(const std::string& arg, unsigned int index) override;
diff --git a/Source/cmCommands.cxx b/Source/cmCommands.cxx
index a1de8b178..dc9318ed6 100644
--- a/Source/cmCommands.cxx
+++ b/Source/cmCommands.cxx
@@ -4,6 +4,7 @@
 #include "cmPolicies.h"
 #include "cmState.h"
 
+#include "cmAddCompileDefinitionsCommand.h"
 #include "cmAddCustomCommandCommand.h"
 #include "cmAddCustomTargetCommand.h"
 #include "cmAddDefinitionsCommand.h"
@@ -80,30 +81,30 @@
 #include "cmWhileCommand.h"
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
-#include "cmAddCompileOptionsCommand.h"
-#include "cmAuxSourceDirectoryCommand.h"
-#include "cmBuildNameCommand.h"
-#include "cmCMakeHostSystemInformationCommand.h"
-#include "cmExportCommand.h"
-#include "cmExportLibraryDependenciesCommand.h"
-#include "cmFLTKWrapUICommand.h"
-#include "cmIncludeExternalMSProjectCommand.h"
-#include "cmInstallProgramsCommand.h"
-#include "cmLinkLibrariesCommand.h"
-#include "cmLoadCacheCommand.h"
-#include "cmLoadCommandCommand.h"
-#include "cmOutputRequiredFilesCommand.h"
-#include "cmQTWrapCPPCommand.h"
-#include "cmQTWrapUICommand.h"
-#include "cmRemoveCommand.h"
-#include "cmRemoveDefinitionsCommand.h"
-#include "cmSourceGroupCommand.h"
-#include "cmSubdirDependsCommand.h"
-#include "cmUseMangledMesaCommand.h"
-#include "cmUtilitySourceCommand.h"
-#include "cmVariableRequiresCommand.h"
-#include "cmVariableWatchCommand.h"
-#include "cmWriteFileCommand.h"
+#  include "cmAddCompileOptionsCommand.h"
+#  include "cmAuxSourceDirectoryCommand.h"
+#  include "cmBuildNameCommand.h"
+#  include "cmCMakeHostSystemInformationCommand.h"
+#  include "cmExportCommand.h"
+#  include "cmExportLibraryDependenciesCommand.h"
+#  include "cmFLTKWrapUICommand.h"
+#  include "cmIncludeExternalMSProjectCommand.h"
+#  include "cmInstallProgramsCommand.h"
+#  include "cmLinkLibrariesCommand.h"
+#  include "cmLoadCacheCommand.h"
+#  include "cmLoadCommandCommand.h"
+#  include "cmOutputRequiredFilesCommand.h"
+#  include "cmQTWrapCPPCommand.h"
+#  include "cmQTWrapUICommand.h"
+#  include "cmRemoveCommand.h"
+#  include "cmRemoveDefinitionsCommand.h"
+#  include "cmSourceGroupCommand.h"
+#  include "cmSubdirDependsCommand.h"
+#  include "cmUseMangledMesaCommand.h"
+#  include "cmUtilitySourceCommand.h"
+#  include "cmVariableRequiresCommand.h"
+#  include "cmVariableWatchCommand.h"
+#  include "cmWriteFileCommand.h"
 #endif
 
 void GetScriptingCommands(cmState* state)
@@ -154,32 +155,39 @@ void GetScriptingCommands(cmState* state)
   state->AddBuiltinCommand("while", new cmWhileCommand);
 
   state->AddUnexpectedCommand(
-    "else", "An ELSE command was found outside of a proper "
-            "IF ENDIF structure. Or its arguments did not match "
-            "the opening IF command.");
+    "else",
+    "An ELSE command was found outside of a proper "
+    "IF ENDIF structure. Or its arguments did not match "
+    "the opening IF command.");
   state->AddUnexpectedCommand(
-    "elseif", "An ELSEIF command was found outside of a proper "
-              "IF ENDIF structure.");
+    "elseif",
+    "An ELSEIF command was found outside of a proper "
+    "IF ENDIF structure.");
   state->AddUnexpectedCommand(
-    "endforeach", "An ENDFOREACH command was found outside of a proper "
-                  "FOREACH ENDFOREACH structure. Or its arguments did "
-                  "not match the opening FOREACH command.");
+    "endforeach",
+    "An ENDFOREACH command was found outside of a proper "
+    "FOREACH ENDFOREACH structure. Or its arguments did "
+    "not match the opening FOREACH command.");
   state->AddUnexpectedCommand(
-    "endfunction", "An ENDFUNCTION command was found outside of a proper "
-                   "FUNCTION ENDFUNCTION structure. Or its arguments did not "
-                   "match the opening FUNCTION command.");
+    "endfunction",
+    "An ENDFUNCTION command was found outside of a proper "
+    "FUNCTION ENDFUNCTION structure. Or its arguments did not "
+    "match the opening FUNCTION command.");
   state->AddUnexpectedCommand(
-    "endif", "An ENDIF command was found outside of a proper "
-             "IF ENDIF structure. Or its arguments did not match "
-             "the opening IF command.");
+    "endif",
+    "An ENDIF command was found outside of a proper "
+    "IF ENDIF structure. Or its arguments did not match "
+    "the opening IF command.");
   state->AddUnexpectedCommand(
-    "endmacro", "An ENDMACRO command was found outside of a proper "
-                "MACRO ENDMACRO structure. Or its arguments did not "
-                "match the opening MACRO command.");
+    "endmacro",
+    "An ENDMACRO command was found outside of a proper "
+    "MACRO ENDMACRO structure. Or its arguments did not "
+    "match the opening MACRO command.");
   state->AddUnexpectedCommand(
-    "endwhile", "An ENDWHILE command was found outside of a proper "
-                "WHILE ENDWHILE structure. Or its arguments did not "
-                "match the opening WHILE command.");
+    "endwhile",
+    "An ENDWHILE command was found outside of a proper "
+    "WHILE ENDWHILE structure. Or its arguments did not "
+    "match the opening WHILE command.");
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
   state->AddBuiltinCommand("cmake_host_system_information",
@@ -253,6 +261,8 @@ void GetProjectCommands(cmState* state)
   state->AddBuiltinCommand("try_run", new cmTryRunCommand);
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
+  state->AddBuiltinCommand("add_compile_definitions",
+                           new cmAddCompileDefinitionsCommand);
   state->AddBuiltinCommand("add_compile_options",
                            new cmAddCompileOptionsCommand);
   state->AddBuiltinCommand("aux_source_directory",
diff --git a/Source/cmCommonTargetGenerator.cxx b/Source/cmCommonTargetGenerator.cxx
index d6d8eb060..a1df27107 100644
--- a/Source/cmCommonTargetGenerator.cxx
+++ b/Source/cmCommonTargetGenerator.cxx
@@ -149,7 +149,8 @@ std::vector<std::string> cmCommonTargetGenerator::GetLinkedTargetDirectories()
     cmComputeLinkInformation::ItemVector const& items = cli->GetItems();
     for (auto const& item : items) {
       cmGeneratorTarget const* linkee = item.Target;
-      if (linkee && !linkee->IsImported()
+      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.
diff --git a/Source/cmComputeLinkDepends.cxx b/Source/cmComputeLinkDepends.cxx
index 354de366e..b1f386094 100644
--- a/Source/cmComputeLinkDepends.cxx
+++ b/Source/cmComputeLinkDepends.cxx
@@ -239,8 +239,9 @@ cmComputeLinkDepends::Compute()
 
   // Display the constraint graph.
   if (this->DebugMode) {
-    fprintf(stderr, "---------------------------------------"
-                    "---------------------------------------\n");
+    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");
diff --git a/Source/cmComputeLinkInformation.cxx b/Source/cmComputeLinkInformation.cxx
index 8a5a6de6c..8d6efdebc 100644
--- a/Source/cmComputeLinkInformation.cxx
+++ b/Source/cmComputeLinkInformation.cxx
@@ -240,21 +240,18 @@ because this need be done only for shared libraries without soname-s.
 
 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->CMakeInstance = this->GlobalGenerator->GetCMakeInstance();
-
+  : Target(target)
+  , Makefile(target->Target->GetMakefile())
+  , GlobalGenerator(target->GetLocalGenerator()->GetGlobalGenerator())
+  , CMakeInstance(this->GlobalGenerator->GetCMakeInstance())
+  // The configuration being linked.
+  , Config(config)
+{
   // Check whether to recognize OpenBSD-style library versioned names.
   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");
@@ -406,17 +403,18 @@ cmComputeLinkInformation::~cmComputeLinkInformation()
 }
 
 cmComputeLinkInformation::ItemVector const&
-cmComputeLinkInformation::GetItems()
+cmComputeLinkInformation::GetItems() const
 {
   return this->Items;
 }
 
 std::vector<std::string> const& cmComputeLinkInformation::GetDirectories()
+  const
 {
   return this->OrderLinkerSearchPath->GetOrderedDirectories();
 }
 
-std::string cmComputeLinkInformation::GetRPathLinkString()
+std::string cmComputeLinkInformation::GetRPathLinkString() const
 {
   // If there is no separate linker runtime search flag (-rpath-link)
   // there is no reason to compute a string.
@@ -428,18 +426,19 @@ std::string cmComputeLinkInformation::GetRPathLinkString()
   return cmJoin(this->OrderDependentRPath->GetOrderedDirectories(), ":");
 }
 
-std::vector<std::string> const& cmComputeLinkInformation::GetDepends()
+std::vector<std::string> const& cmComputeLinkInformation::GetDepends() const
 {
   return this->Depends;
 }
 
 std::vector<std::string> const& cmComputeLinkInformation::GetFrameworkPaths()
+  const
 {
   return this->FrameworkPaths;
 }
 
 const std::set<const cmGeneratorTarget*>&
-cmComputeLinkInformation::GetSharedLibrariesLinked()
+cmComputeLinkInformation::GetSharedLibrariesLinked() const
 {
   return this->SharedLibrariesLinked;
 }
@@ -611,6 +610,9 @@ void cmComputeLinkInformation::AddItem(std::string const& item,
       if (!libName.empty()) {
         this->AddItem(libName, nullptr);
       }
+    } else if (tgt->GetType() == cmStateEnums::OBJECT_LIBRARY) {
+      // Ignore object library!
+      // Its object-files should already have been extracted for linking.
     } else {
       // Decide whether to use an import library.
       bool implib =
@@ -1023,7 +1025,7 @@ void cmComputeLinkInformation::AddFullItem(std::string const& item)
       (generator.find("Visual Studio") != std::string::npos ||
        generator.find("Xcode") != std::string::npos)) {
     std::string file = cmSystemTools::GetFilenameName(item);
-    if (!this->ExtractAnyLibraryName.find(file.c_str())) {
+    if (!this->ExtractAnyLibraryName.find(file)) {
       this->HandleBadFullItem(item, file);
       return;
     }
@@ -1230,7 +1232,7 @@ 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)) {
     std::ostringstream e;
     e << "Could not parse framework path \"" << item << "\" "
       << "linked by target " << this->Target->GetName() << ".";
@@ -1569,7 +1571,7 @@ void cmComputeLinkInformation::LoadImplicitLinkInfo()
 }
 
 std::vector<std::string> const&
-cmComputeLinkInformation::GetRuntimeSearchPath()
+cmComputeLinkInformation::GetRuntimeSearchPath() const
 {
   return this->OrderRuntimeSearchPath->GetOrderedDirectories();
 }
@@ -1635,7 +1637,7 @@ void cmComputeLinkInformation::AddLibraryRuntimeInfo(
   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->ExtractStaticLibraryName.find(file)) {
         // This is the name of a shared library or archive.
         is_shared_library = true;
       }
@@ -1680,7 +1682,7 @@ static void cmCLI_ExpandListUnique(const char* str,
 }
 
 void cmComputeLinkInformation::GetRPath(std::vector<std::string>& runtimeDirs,
-                                        bool for_install)
+                                        bool for_install) const
 {
   // Select whether to generate runtime search directories.
   bool outputRuntime =
@@ -1794,7 +1796,7 @@ void cmComputeLinkInformation::GetRPath(std::vector<std::string>& runtimeDirs,
   cmCLI_ExpandListUnique(this->RuntimeAlways.c_str(), runtimeDirs, emitted);
 }
 
-std::string cmComputeLinkInformation::GetRPathString(bool for_install)
+std::string cmComputeLinkInformation::GetRPathString(bool for_install) const
 {
   // Get the directories to use.
   std::vector<std::string> runtimeDirs;
@@ -1822,7 +1824,7 @@ std::string cmComputeLinkInformation::GetRPathString(bool for_install)
   return rpath;
 }
 
-std::string cmComputeLinkInformation::GetChrpathString()
+std::string cmComputeLinkInformation::GetChrpathString() const
 {
   if (!this->RuntimeUseChrpath) {
     return "";
diff --git a/Source/cmComputeLinkInformation.h b/Source/cmComputeLinkInformation.h
index f8c62145e..e00d230a3 100644
--- a/Source/cmComputeLinkInformation.h
+++ b/Source/cmComputeLinkInformation.h
@@ -48,23 +48,24 @@ public:
     cmGeneratorTarget const* Target;
   };
   typedef std::vector<Item> ItemVector;
-  ItemVector const& GetItems();
-  std::vector<std::string> const& GetDirectories();
-  std::vector<std::string> const& GetDepends();
-  std::vector<std::string> const& GetFrameworkPaths();
+  ItemVector const& GetItems() const;
+  std::vector<std::string> const& GetDirectories() const;
+  std::vector<std::string> const& GetDepends() const;
+  std::vector<std::string> const& GetFrameworkPaths() const;
   std::string GetLinkLanguage() const { return this->LinkLanguage; }
-  std::vector<std::string> const& GetRuntimeSearchPath();
+  std::vector<std::string> const& GetRuntimeSearchPath() const;
   std::string const& GetRuntimeFlag() const { return this->RuntimeFlag; }
   std::string const& GetRuntimeSep() const { return this->RuntimeSep; }
-  void GetRPath(std::vector<std::string>& runtimeDirs, bool for_install);
-  std::string GetRPathString(bool for_install);
-  std::string GetChrpathString();
-  std::set<cmGeneratorTarget const*> const& GetSharedLibrariesLinked();
+  void GetRPath(std::vector<std::string>& runtimeDirs, bool for_install) const;
+  std::string GetRPathString(bool for_install) const;
+  std::string GetChrpathString() const;
+  std::set<cmGeneratorTarget const*> const& GetSharedLibrariesLinked() const;
 
   std::string const& GetRPathLinkFlag() const { return this->RPathLinkFlag; }
-  std::string GetRPathLinkString();
+  std::string GetRPathLinkString() const;
 
   std::string GetConfig() const { return this->Config; }
+
 private:
   void AddItem(std::string const& item, const cmGeneratorTarget* tgt);
   void AddSharedDepItem(std::string const& item, cmGeneratorTarget const* tgt);
@@ -78,13 +79,13 @@ private:
   std::set<cmGeneratorTarget const*> SharedLibrariesLinked;
 
   // Context information.
-  cmGeneratorTarget const* Target;
-  cmMakefile* Makefile;
-  cmGlobalGenerator* GlobalGenerator;
-  cmake* CMakeInstance;
+  cmGeneratorTarget const* const Target;
+  cmMakefile* const Makefile;
+  cmGlobalGenerator* const GlobalGenerator;
+  cmake* const CMakeInstance;
 
   // Configuration information.
-  std::string Config;
+  std::string const Config;
   std::string LinkLanguage;
 
   // Modes for dealing with dependent shared libraries.
diff --git a/Source/cmComputeTargetDepends.cxx b/Source/cmComputeTargetDepends.cxx
index 18767a362..efdd3a5f8 100644
--- a/Source/cmComputeTargetDepends.cxx
+++ b/Source/cmComputeTargetDepends.cxx
@@ -211,11 +211,11 @@ void cmComputeTargetDepends::CollectTargetDepends(int depender_index)
           if (depender->GetType() != cmStateEnums::EXECUTABLE &&
               depender->GetType() != cmStateEnums::STATIC_LIBRARY &&
               depender->GetType() != cmStateEnums::SHARED_LIBRARY &&
-              depender->GetType() != cmStateEnums::MODULE_LIBRARY) {
+              depender->GetType() != cmStateEnums::MODULE_LIBRARY &&
+              depender->GetType() != cmStateEnums::OBJECT_LIBRARY) {
             this->GlobalGenerator->GetCMakeInstance()->IssueMessage(
               cmake::FATAL_ERROR,
-              "Only executables and non-OBJECT libraries may "
-              "reference target objects.",
+              "Only executables and libraries may reference target objects.",
               depender->GetBacktrace());
             return;
           }
diff --git a/Source/cmConfigureFileCommand.h b/Source/cmConfigureFileCommand.h
index cff934b48..5603c505c 100644
--- a/Source/cmConfigureFileCommand.h
+++ b/Source/cmConfigureFileCommand.h
@@ -32,9 +32,9 @@ private:
 
   std::string InputFile;
   std::string OutputFile;
-  bool CopyOnly;
-  bool EscapeQuotes;
-  bool AtOnly;
+  bool CopyOnly = false;
+  bool EscapeQuotes = false;
+  bool AtOnly = false;
 };
 
 #endif
diff --git a/Source/cmCoreTryCompile.cxx b/Source/cmCoreTryCompile.cxx
index 26e0db9e2..0b50121ae 100644
--- a/Source/cmCoreTryCompile.cxx
+++ b/Source/cmCoreTryCompile.cxx
@@ -82,17 +82,20 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv,
     if (strcmp(tt, cmState::GetTargetTypeName(cmStateEnums::EXECUTABLE)) ==
         0) {
       targetType = cmStateEnums::EXECUTABLE;
-    } else if (strcmp(tt, cmState::GetTargetTypeName(
-                            cmStateEnums::STATIC_LIBRARY)) == 0) {
+    } else if (strcmp(tt,
+                      cmState::GetTargetTypeName(
+                        cmStateEnums::STATIC_LIBRARY)) == 0) {
       targetType = cmStateEnums::STATIC_LIBRARY;
     } else {
       this->Makefile->IssueMessage(
-        cmake::FATAL_ERROR, std::string("Invalid value '") + tt +
+        cmake::FATAL_ERROR,
+        std::string("Invalid value '") + tt +
           "' for "
           "CMAKE_TRY_COMPILE_TARGET_TYPE.  Only "
           "'" +
-          cmState::GetTargetTypeName(cmStateEnums::EXECUTABLE) + "' and "
-                                                                 "'" +
+          cmState::GetTargetTypeName(cmStateEnums::EXECUTABLE) +
+          "' and "
+          "'" +
           cmState::GetTargetTypeName(cmStateEnums::STATIC_LIBRARY) +
           "' "
           "are allowed.");
@@ -224,8 +227,9 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv,
               cmake::FATAL_ERROR,
               "Only libraries may be used as try_compile or try_run IMPORTED "
               "LINK_LIBRARIES.  Got " +
-                std::string(tgt->GetName()) + " of "
-                                              "type " +
+                std::string(tgt->GetName()) +
+                " of "
+                "type " +
                 cmState::GetTargetTypeName(tgt->GetType()) + ".");
             return -1;
         }
@@ -487,8 +491,9 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv,
       const char* flags = this->Makefile->GetDefinition(langFlags);
       fprintf(fout, "set(CMAKE_%s_FLAGS %s)\n", li.c_str(),
               cmOutputConverter::EscapeForCMake(flags ? flags : "").c_str());
-      fprintf(fout, "set(CMAKE_%s_FLAGS \"${CMAKE_%s_FLAGS}"
-                    " ${COMPILE_DEFINITIONS}\")\n",
+      fprintf(fout,
+              "set(CMAKE_%s_FLAGS \"${CMAKE_%s_FLAGS}"
+              " ${COMPILE_DEFINITIONS}\")\n",
               li.c_str(), li.c_str());
     }
     switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0066)) {
@@ -563,8 +568,9 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv,
         }
         break;
     }
-    fprintf(fout, "set(CMAKE_EXE_LINKER_FLAGS \"${CMAKE_EXE_LINKER_FLAGS}"
-                  " ${EXE_LINKER_FLAGS}\")\n");
+    fprintf(fout,
+            "set(CMAKE_EXE_LINKER_FLAGS \"${CMAKE_EXE_LINKER_FLAGS}"
+            " ${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");
@@ -818,7 +824,8 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv,
   // actually do the try compile now that everything is setup
   int res = this->Makefile->TryCompile(
     sourceDirectory, this->BinaryDirectory, projectName, targetName,
-    this->SrcFileSignature, &cmakeFlags, output);
+    this->SrcFileSignature, cmake::NO_BUILD_PARALLEL_LEVEL, &cmakeFlags,
+    output);
   if (erroroc) {
     cmSystemTools::SetErrorOccured();
   }
diff --git a/Source/cmCoreTryCompile.h b/Source/cmCoreTryCompile.h
index 6f35a540f..ae714a63a 100644
--- a/Source/cmCoreTryCompile.h
+++ b/Source/cmCoreTryCompile.h
@@ -46,7 +46,7 @@ protected:
   std::string BinaryDirectory;
   std::string OutputFile;
   std::string FindErrorMessage;
-  bool SrcFileSignature;
+  bool SrcFileSignature = false;
 
 private:
   std::vector<std::string> WarnCMP0067;
diff --git a/Source/cmCurl.cxx b/Source/cmCurl.cxx
index 8ef8bffe8..3360323f0 100644
--- a/Source/cmCurl.cxx
+++ b/Source/cmCurl.cxx
@@ -6,13 +6,13 @@
 
 #if !defined(CMAKE_USE_SYSTEM_CURL) && !defined(_WIN32) &&                    \
   !defined(__APPLE__) && !defined(CURL_CA_BUNDLE) && !defined(CURL_CA_PATH)
-#define CMAKE_FIND_CAFILE
-#include "cmSystemTools.h"
+#  define CMAKE_FIND_CAFILE
+#  include "cmSystemTools.h"
 #endif
 
 // 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)                                     \
@@ -30,28 +30,28 @@ std::string cmCurlSetCAInfo(::CURL* curl, const char* cafile)
     check_curl_result(res, "Unable to set TLS/SSL Verify CAINFO: ");
   }
 #ifdef CMAKE_FIND_CAFILE
-#define CMAKE_CAFILE_FEDORA "/etc/pki/tls/certs/ca-bundle.crt"
+#  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
+#  undef CMAKE_CAFILE_FEDORA
   else {
-#define CMAKE_CAFILE_COMMON "/etc/ssl/certs/ca-certificates.crt"
+#  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"
+#  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/cmDepends.cxx b/Source/cmDepends.cxx
index cdab671a7..4716e14d6 100644
--- a/Source/cmDepends.cxx
+++ b/Source/cmDepends.cxx
@@ -7,7 +7,6 @@
 #include "cmLocalGenerator.h"
 #include "cmMakefile.h"
 #include "cmSystemTools.h"
-#include "cmWorkingDirectory.h"
 
 #include "cmsys/FStream.hxx"
 #include <sstream>
@@ -15,8 +14,7 @@
 #include <utility>
 
 cmDepends::cmDepends(cmLocalGenerator* lg, const char* targetDir)
-  : CompileDirectory()
-  , LocalGenerator(lg)
+  : LocalGenerator(lg)
   , Verbose(false)
   , FileComparison(nullptr)
   , TargetDirectory(targetDir)
@@ -73,9 +71,6 @@ bool cmDepends::Finalize(std::ostream& /*unused*/, std::ostream& /*unused*/)
 bool cmDepends::Check(const char* makeFile, const char* internalFile,
                       std::map<std::string, DependencyVector>& validDeps)
 {
-  // Dependency checks must be done in proper working directory.
-  cmWorkingDirectory workdir(this->CompileDirectory);
-
   // Check whether dependencies must be regenerated.
   bool okay = true;
   cmsys::ifstream fin(internalFile);
diff --git a/Source/cmDepends.h b/Source/cmDepends.h
index a4fee3c8a..4b9e05a88 100644
--- a/Source/cmDepends.h
+++ b/Source/cmDepends.h
@@ -31,9 +31,6 @@ public:
       path from the build directory to the target file.  */
   cmDepends(cmLocalGenerator* lg = nullptr, const char* targetDir = "");
 
-  /** at what level will the compile be done from */
-  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
       has been setup to do relative path conversions for the current
@@ -95,9 +92,6 @@ protected:
   virtual bool Finalize(std::ostream& makeDepends,
                         std::ostream& internalDepends);
 
-  // The directory in which the build rule for the target file is executed.
-  std::string CompileDirectory;
-
   // The local generator.
   cmLocalGenerator* LocalGenerator;
 
diff --git a/Source/cmDependsC.cxx b/Source/cmDependsC.cxx
index 62bc8d9ef..34c0e9403 100644
--- a/Source/cmDependsC.cxx
+++ b/Source/cmDependsC.cxx
@@ -96,9 +96,16 @@ bool cmDependsC::WriteDependencies(const std::set<std::string>& sources,
   std::set<std::string> dependencies;
   bool haveDeps = false;
 
+  std::string binDir = this->LocalGenerator->GetBinaryDirectory();
+
+  // Compute a path to the object file to write to the internal depend file.
+  // Any existing content of the internal depend file has already been
+  // loaded in ValidDeps with this path as a key.
+  std::string obj_i = this->LocalGenerator->ConvertToRelativePath(binDir, obj);
+
   if (this->ValidDeps != nullptr) {
     std::map<std::string, DependencyVector>::const_iterator tmpIt =
-      this->ValidDeps->find(obj);
+      this->ValidDeps->find(obj_i);
     if (tmpIt != this->ValidDeps->end()) {
       dependencies.insert(tmpIt->second.begin(), tmpIt->second.end());
       haveDeps = true;
@@ -222,8 +229,6 @@ bool cmDependsC::WriteDependencies(const std::set<std::string>& sources,
   // written by the original local generator for this directory
   // convert the dependencies to paths relative to the home output
   // directory.  We must do the same here.
-  std::string binDir = this->LocalGenerator->GetBinaryDirectory();
-  std::string obj_i = this->LocalGenerator->ConvertToRelativePath(binDir, obj);
   std::string obj_m = cmSystemTools::ConvertToOutputPath(obj_i);
   internalDepends << obj_i << std::endl;
 
diff --git a/Source/cmDependsFortran.cxx b/Source/cmDependsFortran.cxx
index 1a66ca026..dbea15ae0 100644
--- a/Source/cmDependsFortran.cxx
+++ b/Source/cmDependsFortran.cxx
@@ -10,6 +10,7 @@
 #include <string.h>
 #include <utility>
 
+#include "cmAlgorithms.h"
 #include "cmFortranParser.h" /* Interface to parser object.  */
 #include "cmGeneratedFileStream.h"
 #include "cmLocalGenerator.h"
@@ -23,6 +24,22 @@
 // use lower case and some always use upper case.  I do not know if any
 // use the case from the source code.
 
+static void cmFortranModuleAppendUpperLower(std::string const& mod,
+                                            std::string& mod_upper,
+                                            std::string& mod_lower)
+{
+  std::string::size_type ext_len = 0;
+  if (cmHasLiteralSuffix(mod, ".mod")) {
+    ext_len = 4;
+  } else if (cmHasLiteralSuffix(mod, ".smod")) {
+    ext_len = 5;
+  }
+  std::string const& name = mod.substr(0, mod.size() - ext_len);
+  std::string const& ext = mod.substr(mod.size() - ext_len);
+  mod_upper += cmSystemTools::UpperCase(name) + ext;
+  mod_lower += mod;
+}
+
 class cmDependsFortranInternals
 {
 public:
@@ -181,16 +198,13 @@ bool cmDependsFortran::Finalize(std::ostream& makeDepends,
     for (std::string const& i : provides) {
       std::string mod_upper = mod_dir;
       mod_upper += "/";
-      mod_upper += cmSystemTools::UpperCase(i);
-      mod_upper += ".mod";
       std::string mod_lower = mod_dir;
       mod_lower += "/";
-      mod_lower += i;
-      mod_lower += ".mod";
+      cmFortranModuleAppendUpperLower(i, mod_upper, mod_lower);
       std::string stamp = stamp_dir;
       stamp += "/";
       stamp += i;
-      stamp += ".mod.stamp";
+      stamp += ".stamp";
       fcStream << "\n";
       fcStream << "  \""
                << this->MaybeConvertToRelativePath(currentBinDir, mod_lower)
@@ -270,7 +284,14 @@ void cmDependsFortran::MatchRemoteModules(std::istream& fin,
 
     if (line[0] == ' ') {
       if (doing_provides) {
-        this->ConsiderModule(line.c_str() + 1, stampDir);
+        std::string mod = line;
+        if (!cmHasLiteralSuffix(mod, ".mod") &&
+            !cmHasLiteralSuffix(mod, ".smod")) {
+          // Support fortran.internal files left by older versions of CMake.
+          // They do not include the ".mod" extension.
+          mod += ".mod";
+        }
+        this->ConsiderModule(mod.c_str() + 1, stampDir);
       }
     } else if (line == "provides") {
       doing_provides = true;
@@ -292,7 +313,7 @@ void cmDependsFortran::ConsiderModule(const char* name, const char* stampDir)
     std::string stampFile = stampDir;
     stampFile += "/";
     stampFile += name;
-    stampFile += ".mod.stamp";
+    stampFile += ".stamp";
     required->second = stampFile;
   }
 }
@@ -366,7 +387,6 @@ bool cmDependsFortran::WriteDependenciesReal(const char* obj,
       // Always use lower case for the mod stamp file name.  The
       // cmake_copy_f90_mod will call back to this class, which will
       // try various cases for the real mod file name.
-      std::string m = cmSystemTools::LowerCase(i);
       std::string modFile = mod_dir;
       modFile += "/";
       modFile += i;
@@ -375,8 +395,8 @@ bool cmDependsFortran::WriteDependenciesReal(const char* obj,
         cmOutputConverter::SHELL);
       std::string stampFile = stamp_dir;
       stampFile += "/";
-      stampFile += m;
-      stampFile += ".mod.stamp";
+      stampFile += i;
+      stampFile += ".stamp";
       stampFile = this->MaybeConvertToRelativePath(binDir, stampFile);
       std::string const stampFileForShell =
         this->LocalGenerator->ConvertToOutputFormat(stampFile,
@@ -423,10 +443,9 @@ bool cmDependsFortran::WriteDependenciesReal(const char* obj,
 bool cmDependsFortran::FindModule(std::string const& name, std::string& module)
 {
   // Construct possible names for the module file.
-  std::string mod_upper = cmSystemTools::UpperCase(name);
-  std::string mod_lower = name;
-  mod_upper += ".mod";
-  mod_lower += ".mod";
+  std::string mod_upper;
+  std::string mod_lower;
+  cmFortranModuleAppendUpperLower(name, mod_upper, mod_lower);
 
   // Search the include path for the module.
   std::string fullName;
@@ -470,17 +489,19 @@ bool cmDependsFortran::CopyModule(const std::vector<std::string>& args)
   if (args.size() >= 5) {
     compilerId = args[4];
   }
+  if (!cmHasLiteralSuffix(mod, ".mod") && !cmHasLiteralSuffix(mod, ".smod")) {
+    // Support depend.make files left by older versions of CMake.
+    // They do not include the ".mod" extension.
+    mod += ".mod";
+  }
   std::string mod_dir = cmSystemTools::GetFilenamePath(mod);
   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;
-  mod_lower += cmSystemTools::LowerCase(cmSystemTools::GetFilenameName(mod));
-  mod += ".mod";
-  mod_upper += ".mod";
-  mod_lower += ".mod";
+  cmFortranModuleAppendUpperLower(cmSystemTools::GetFilenameName(mod),
+                                  mod_upper, mod_lower);
   if (cmSystemTools::FileExists(mod_upper, true)) {
     if (cmDependsFortran::ModulesDiffer(mod_upper.c_str(), stamp.c_str(),
                                         compilerId.c_str())) {
diff --git a/Source/cmELF.cxx b/Source/cmELF.cxx
index 77ccd3096..0ccd68a97 100644
--- a/Source/cmELF.cxx
+++ b/Source/cmELF.cxx
@@ -13,39 +13,39 @@
 
 // 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>
+#  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
+#  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
 #ifdef _SCO_DS
-#include <link.h> // For DT_SONAME etc.
+#  include <link.h> // For DT_SONAME etc.
 #endif
 #ifndef DT_RUNPATH
-#define DT_RUNPATH 29
+#  define DT_RUNPATH 29
 #endif
 
 // Low-level byte swapping implementation.
@@ -162,6 +162,7 @@ public:
 
   // Return the recorded ELF type.
   cmELF::FileType GetFileType() const { return this->ELFType; }
+
 protected:
   // Data common to all ELF class implementations.
 
diff --git a/Source/cmELF.h b/Source/cmELF.h
index 8c1734888..9172f3803 100644
--- a/Source/cmELF.h
+++ b/Source/cmELF.h
@@ -11,7 +11,7 @@
 #include <vector>
 
 #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;
diff --git a/Source/cmExecProgramCommand.cxx b/Source/cmExecProgramCommand.cxx
index 49f880c87..ea4cd4071 100644
--- a/Source/cmExecProgramCommand.cxx
+++ b/Source/cmExecProgramCommand.cxx
@@ -194,9 +194,9 @@ bool cmExecProgramCommand::RunCommand(const char* command, std::string& output,
   } else {
     commandInDir = command;
   }
-#ifndef __VMS
+#  ifndef __VMS
   commandInDir += " 2>&1";
-#endif
+#  endif
   command = commandInDir.c_str();
   if (verbose) {
     cmSystemTools::Stdout("running ");
diff --git a/Source/cmExportBuildAndroidMKGenerator.cxx b/Source/cmExportBuildAndroidMKGenerator.cxx
index 817b5d9eb..0ceac85e3 100644
--- a/Source/cmExportBuildAndroidMKGenerator.cxx
+++ b/Source/cmExportBuildAndroidMKGenerator.cxx
@@ -41,7 +41,8 @@ void cmExportBuildAndroidMKGenerator::GenerateExpectedTargetsCode(
 }
 
 void cmExportBuildAndroidMKGenerator::GenerateImportTargetCode(
-  std::ostream& os, const cmGeneratorTarget* target)
+  std::ostream& os, cmGeneratorTarget const* target,
+  cmStateEnums::TargetType /*targetType*/)
 {
   std::string targetName = this->Namespace;
   targetName += target->GetExportName();
diff --git a/Source/cmExportBuildAndroidMKGenerator.h b/Source/cmExportBuildAndroidMKGenerator.h
index c80839bd4..a9b6107f8 100644
--- a/Source/cmExportBuildAndroidMKGenerator.h
+++ b/Source/cmExportBuildAndroidMKGenerator.h
@@ -11,6 +11,7 @@
 
 #include "cmExportBuildFileGenerator.h"
 #include "cmExportFileGenerator.h"
+#include "cmStateTypes.h"
 
 class cmGeneratorTarget;
 
@@ -47,8 +48,9 @@ protected:
   void GenerateImportHeaderCode(std::ostream& os,
                                 const std::string& config = "") override;
   void GenerateImportFooterCode(std::ostream& os) override;
-  void GenerateImportTargetCode(std::ostream& os,
-                                const cmGeneratorTarget* target) override;
+  void GenerateImportTargetCode(
+    std::ostream& os, cmGeneratorTarget const* target,
+    cmStateEnums::TargetType /*targetType*/) override;
   void GenerateExpectedTargetsCode(
     std::ostream& os, const std::string& expectedTargets) override;
   void GenerateImportPropertyCode(
diff --git a/Source/cmExportBuildFileGenerator.cxx b/Source/cmExportBuildFileGenerator.cxx
index f7aa6e86f..47636cd23 100644
--- a/Source/cmExportBuildFileGenerator.cxx
+++ b/Source/cmExportBuildFileGenerator.cxx
@@ -59,7 +59,7 @@ bool cmExportBuildFileGenerator::GenerateMainFile(std::ostream& os)
           this->LG->GetMakefile()->GetBacktrace());
         return false;
       }
-      if (te->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
+      if (this->GetExportTargetType(te) == cmStateEnums::INTERFACE_LIBRARY) {
         this->GenerateRequiredCMakeVersion(os, "3.0.0");
       }
     }
@@ -71,7 +71,7 @@ bool cmExportBuildFileGenerator::GenerateMainFile(std::ostream& os)
 
   // Create all the imported targets.
   for (cmGeneratorTarget* gte : this->Exports) {
-    this->GenerateImportTargetCode(os, gte);
+    this->GenerateImportTargetCode(os, gte, this->GetExportTargetType(gte));
 
     gte->Target->AppendBuildInterfaceIncludes();
 
@@ -97,6 +97,15 @@ bool cmExportBuildFileGenerator::GenerateMainFile(std::ostream& os)
                                     properties, missingTargets);
     this->PopulateInterfaceProperty("INTERFACE_POSITION_INDEPENDENT_CODE", gte,
                                     properties);
+
+    std::string errorMessage;
+    if (!this->PopulateExportProperties(gte, properties, errorMessage)) {
+      this->LG->GetGlobalGenerator()->GetCMakeInstance()->IssueMessage(
+        cmake::FATAL_ERROR, errorMessage,
+        this->LG->GetMakefile()->GetBacktrace());
+      return false;
+    }
+
     const bool newCMP0022Behavior =
       gte->GetPolicyStatusCMP0022() != cmPolicies::WARN &&
       gte->GetPolicyStatusCMP0022() != cmPolicies::OLD;
@@ -128,12 +137,13 @@ void cmExportBuildFileGenerator::GenerateImportTargetsConfig(
     // Collect import properties for this target.
     ImportPropertyMap properties;
 
-    if (target->GetType() != cmStateEnums::INTERFACE_LIBRARY) {
+    if (this->GetExportTargetType(target) != cmStateEnums::INTERFACE_LIBRARY) {
       this->SetImportLocationProperty(config, suffix, target, properties);
     }
     if (!properties.empty()) {
       // Get the rest of the target details.
-      if (target->GetType() != cmStateEnums::INTERFACE_LIBRARY) {
+      if (this->GetExportTargetType(target) !=
+          cmStateEnums::INTERFACE_LIBRARY) {
         this->SetImportDetailProperties(config, suffix, target, properties,
                                         missingTargets);
         this->SetImportLinkInterface(config, suffix,
@@ -141,7 +151,7 @@ void cmExportBuildFileGenerator::GenerateImportTargetsConfig(
                                      target, properties, missingTargets);
       }
 
-      // TOOD: PUBLIC_HEADER_LOCATION
+      // TODO: PUBLIC_HEADER_LOCATION
       // This should wait until the build feature propagation stuff
       // is done.  Then this can be a propagated include directory.
       // this->GenerateImportProperty(config, te->HeaderGenerator,
@@ -153,6 +163,21 @@ void cmExportBuildFileGenerator::GenerateImportTargetsConfig(
   }
 }
 
+cmStateEnums::TargetType cmExportBuildFileGenerator::GetExportTargetType(
+  cmGeneratorTarget const* target) const
+{
+  cmStateEnums::TargetType targetType = target->GetType();
+  // An object library exports as an interface library if we cannot
+  // tell clients where to find the objects.  This is sufficient
+  // to support transitive usage requirements on other targets that
+  // use the object library.
+  if (targetType == cmStateEnums::OBJECT_LIBRARY &&
+      !this->LG->GetGlobalGenerator()->HasKnownObjectFileLocation(nullptr)) {
+    targetType = cmStateEnums::INTERFACE_LIBRARY;
+  }
+  return targetType;
+}
+
 void cmExportBuildFileGenerator::SetExportSet(cmExportSet* exportSet)
 {
   this->ExportSet = exportSet;
@@ -199,13 +224,14 @@ void cmExportBuildFileGenerator::SetImportLocationProperty(
     }
 
     // Add the import library for windows DLLs.
-    if (target->HasImportLibrary() &&
+    if (target->HasImportLibrary(config) &&
         mf->GetDefinition("CMAKE_IMPORT_LIBRARY_SUFFIX")) {
       std::string prop = "IMPORTED_IMPLIB";
       prop += suffix;
       std::string value =
         target->GetFullPath(config, cmStateEnums::ImportLibraryArtifact);
-      target->GetImplibGNUtoMS(value, value, "${CMAKE_IMPORT_LIBRARY_SUFFIX}");
+      target->GetImplibGNUtoMS(config, value, value,
+                               "${CMAKE_IMPORT_LIBRARY_SUFFIX}");
       properties[prop] = value;
     }
   }
diff --git a/Source/cmExportBuildFileGenerator.h b/Source/cmExportBuildFileGenerator.h
index 6457a7787..ada270996 100644
--- a/Source/cmExportBuildFileGenerator.h
+++ b/Source/cmExportBuildFileGenerator.h
@@ -6,6 +6,7 @@
 #include "cmConfigure.h" // IWYU pragma: keep
 
 #include "cmExportFileGenerator.h"
+#include "cmStateTypes.h"
 
 #include <iosfwd>
 #include <string>
@@ -53,6 +54,8 @@ protected:
   void GenerateImportTargetsConfig(
     std::ostream& os, const std::string& config, std::string const& suffix,
     std::vector<std::string>& missingTargets) override;
+  cmStateEnums::TargetType GetExportTargetType(
+    cmGeneratorTarget const* target) const;
   void HandleMissingTarget(std::string& link_libs,
                            std::vector<std::string>& missingTargets,
                            cmGeneratorTarget* depender,
diff --git a/Source/cmExportCommand.cxx b/Source/cmExportCommand.cxx
index c8a727d70..4e1d7713a 100644
--- a/Source/cmExportCommand.cxx
+++ b/Source/cmExportCommand.cxx
@@ -20,8 +20,8 @@
 class cmExecutionStatus;
 
 #if defined(__HAIKU__)
-#include <FindDirectory.h>
-#include <StorageDefs.h>
+#  include <FindDirectory.h>
+#  include <StorageDefs.h>
 #endif
 
 cmExportCommand::cmExportCommand()
@@ -146,17 +146,6 @@ bool cmExportCommand::InitialPass(std::vector<std::string> const& args,
       }
 
       if (cmTarget* target = gg->FindTarget(currentTarget)) {
-        if (target->GetType() == cmStateEnums::OBJECT_LIBRARY) {
-          std::string reason;
-          if (!this->Makefile->GetGlobalGenerator()
-                 ->HasKnownObjectFileLocation(&reason)) {
-            std::ostringstream e;
-            e << "given OBJECT library \"" << currentTarget
-              << "\" which may not be exported" << reason << ".";
-            this->SetError(e.str());
-            return false;
-          }
-        }
         if (target->GetType() == cmStateEnums::UTILITY) {
           this->SetError("given custom target \"" + currentTarget +
                          "\" which may not be exported.");
@@ -277,7 +266,7 @@ bool cmExportCommand::HandlePackage(std::vector<std::string> const& args)
 }
 
 #if defined(_WIN32) && !defined(__CYGWIN__)
-#include <windows.h>
+#  include <windows.h>
 
 void cmExportCommand::ReportRegistryError(std::string const& msg,
                                           std::string const& key, long err)
@@ -328,7 +317,7 @@ void cmExportCommand::StorePackageRegistryDir(std::string const& package,
                                               const char* content,
                                               const char* hash)
 {
-#if defined(__HAIKU__)
+#  if defined(__HAIKU__)
   char dir[B_PATH_NAME_LENGTH];
   if (find_directory(B_USER_SETTINGS_DIRECTORY, -1, false, dir, sizeof(dir)) !=
       B_OK) {
@@ -337,7 +326,7 @@ void cmExportCommand::StorePackageRegistryDir(std::string const& package,
   std::string fname = dir;
   fname += "/cmake/packages/";
   fname += package;
-#else
+#  else
   std::string fname;
   if (!cmSystemTools::GetEnv("HOME", fname)) {
     return;
@@ -345,7 +334,7 @@ void cmExportCommand::StorePackageRegistryDir(std::string const& package,
   cmSystemTools::ConvertToUnixSlashes(fname);
   fname += "/.cmake/packages/";
   fname += package;
-#endif
+#  endif
   cmSystemTools::MakeDirectory(fname);
   fname += "/";
   fname += hash;
diff --git a/Source/cmExportFileGenerator.cxx b/Source/cmExportFileGenerator.cxx
index 434abdc76..5f615714b 100644
--- a/Source/cmExportFileGenerator.cxx
+++ b/Source/cmExportFileGenerator.cxx
@@ -11,6 +11,8 @@
 #include "cmMakefile.h"
 #include "cmOutputConverter.h"
 #include "cmPolicies.h"
+#include "cmProperty.h"
+#include "cmPropertyMap.h"
 #include "cmStateTypes.h"
 #include "cmSystemTools.h"
 #include "cmTarget.h"
@@ -264,10 +266,12 @@ static bool checkInterfaceDirs(const std::string& prepro,
               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 "
+                << 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;
@@ -775,6 +779,25 @@ void cmExportFileGenerator::SetImportDetailProperties(
       properties[prop] = m.str();
     }
   }
+
+  // Add information if this target is a managed target
+  if (target->GetManagedType(config) !=
+      cmGeneratorTarget::ManagedType::Native) {
+    std::string prop = "IMPORTED_COMMON_LANGUAGE_RUNTIME";
+    prop += suffix;
+    std::string propval;
+    if (auto* p = target->GetProperty("COMMON_LANGUAGE_RUNTIME")) {
+      propval = p;
+    } else if (target->HasLanguage("CSharp", config)) {
+      // C# projects do not have the /clr flag, so we set the property
+      // here to mark the target as (only) managed (i.e. no .lib file
+      // to link to). Otherwise the  COMMON_LANGUAGE_RUNTIME target
+      // property would have to be set manually for C# targets to make
+      // exporting/importing work.
+      propval = "CSharp";
+    }
+    properties[prop] = propval;
+  }
 }
 
 template <typename T>
@@ -901,8 +924,10 @@ void cmExportFileGenerator::GenerateExpectedTargetsCode(
         "\n\n";
   /* clang-format on */
 }
+
 void cmExportFileGenerator::GenerateImportTargetCode(
-  std::ostream& os, const cmGeneratorTarget* target)
+  std::ostream& os, cmGeneratorTarget const* target,
+  cmStateEnums::TargetType targetType)
 {
   // Construct the imported target name.
   std::string targetName = this->Namespace;
@@ -911,7 +936,7 @@ void cmExportFileGenerator::GenerateImportTargetCode(
 
   // Create the imported target.
   os << "# Create imported target " << targetName << "\n";
-  switch (target->GetType()) {
+  switch (targetType) {
     case cmStateEnums::EXECUTABLE:
       os << "add_executable(" << targetName << " IMPORTED)\n";
       break;
@@ -1095,3 +1120,41 @@ void cmExportFileGenerator::GenerateImportedFileChecksCode(
 
   os << ")\n\n";
 }
+
+bool cmExportFileGenerator::PopulateExportProperties(
+  cmGeneratorTarget* gte, ImportPropertyMap& properties,
+  std::string& errorMessage)
+{
+  auto& targetProperties = gte->Target->GetProperties();
+  const auto& exportProperties = targetProperties.find("EXPORT_PROPERTIES");
+  if (exportProperties != targetProperties.end()) {
+    std::vector<std::string> propsToExport;
+    cmSystemTools::ExpandListArgument(exportProperties->second.GetValue(),
+                                      propsToExport);
+    for (auto& prop : propsToExport) {
+      /* Black list reserved properties */
+      if (cmSystemTools::StringStartsWith(prop, "IMPORTED_") ||
+          cmSystemTools::StringStartsWith(prop, "INTERFACE_")) {
+        std::ostringstream e;
+        e << "Target \"" << gte->Target->GetName() << "\" contains property \""
+          << prop << "\" in EXPORT_PROPERTIES but IMPORTED_* and INTERFACE_* "
+          << "properties are reserved.";
+        errorMessage = e.str();
+        return false;
+      }
+      auto propertyValue = targetProperties.GetPropertyValue(prop);
+      std::string evaluatedValue = cmGeneratorExpression::Preprocess(
+        propertyValue, cmGeneratorExpression::StripAllGeneratorExpressions);
+      if (evaluatedValue != propertyValue) {
+        std::ostringstream e;
+        e << "Target \"" << gte->Target->GetName() << "\" contains property \""
+          << prop << "\" in EXPORT_PROPERTIES but this property contains a "
+          << "generator expression. This is not allowed.";
+        errorMessage = e.str();
+        return false;
+      }
+      properties[prop] = propertyValue;
+    }
+  }
+  return true;
+}
diff --git a/Source/cmExportFileGenerator.h b/Source/cmExportFileGenerator.h
index 985c8f6bc..954e6c5f8 100644
--- a/Source/cmExportFileGenerator.h
+++ b/Source/cmExportFileGenerator.h
@@ -6,6 +6,7 @@
 #include "cmConfigure.h" // IWYU pragma: keep
 
 #include "cmGeneratorExpression.h"
+#include "cmStateTypes.h"
 #include "cmVersion.h"
 #include "cmVersionConfig.h"
 
@@ -76,7 +77,8 @@ protected:
   virtual void GenerateImportFooterCode(std::ostream& os);
   void GenerateImportVersionCode(std::ostream& os);
   virtual void GenerateImportTargetCode(std::ostream& os,
-                                        cmGeneratorTarget const* target);
+                                        cmGeneratorTarget const* target,
+                                        cmStateEnums::TargetType targetType);
   virtual void GenerateImportPropertyCode(std::ostream& os,
                                           const std::string& config,
                                           cmGeneratorTarget const* target,
@@ -166,6 +168,10 @@ protected:
   virtual void GenerateRequiredCMakeVersion(std::ostream& os,
                                             const char* versionString);
 
+  bool PopulateExportProperties(cmGeneratorTarget* gte,
+                                ImportPropertyMap& properties,
+                                std::string& errorMessage);
+
   // The namespace in which the exports are placed in the generated file.
   std::string Namespace;
 
diff --git a/Source/cmExportInstallAndroidMKGenerator.cxx b/Source/cmExportInstallAndroidMKGenerator.cxx
index fe565e623..9bc8089dc 100644
--- a/Source/cmExportInstallAndroidMKGenerator.cxx
+++ b/Source/cmExportInstallAndroidMKGenerator.cxx
@@ -55,7 +55,8 @@ void cmExportInstallAndroidMKGenerator::GenerateImportFooterCode(std::ostream&)
 }
 
 void cmExportInstallAndroidMKGenerator::GenerateImportTargetCode(
-  std::ostream& os, const cmGeneratorTarget* target)
+  std::ostream& os, cmGeneratorTarget const* target,
+  cmStateEnums::TargetType /*targetType*/)
 {
   std::string targetName = this->Namespace;
   targetName += target->GetExportName();
diff --git a/Source/cmExportInstallAndroidMKGenerator.h b/Source/cmExportInstallAndroidMKGenerator.h
index 91554ee30..8883ffafb 100644
--- a/Source/cmExportInstallAndroidMKGenerator.h
+++ b/Source/cmExportInstallAndroidMKGenerator.h
@@ -12,6 +12,7 @@
 
 #include "cmExportFileGenerator.h"
 #include "cmExportInstallFileGenerator.h"
+#include "cmStateTypes.h"
 
 class cmGeneratorTarget;
 class cmInstallExportGenerator;
@@ -41,8 +42,9 @@ protected:
   void GenerateImportHeaderCode(std::ostream& os,
                                 const std::string& config = "") override;
   void GenerateImportFooterCode(std::ostream& os) override;
-  void GenerateImportTargetCode(std::ostream& os,
-                                const cmGeneratorTarget* target) override;
+  void GenerateImportTargetCode(
+    std::ostream& os, cmGeneratorTarget const* target,
+    cmStateEnums::TargetType /*targetType*/) override;
   void GenerateExpectedTargetsCode(
     std::ostream& os, const std::string& expectedTargets) override;
   void GenerateImportPropertyCode(
diff --git a/Source/cmExportInstallFileGenerator.cxx b/Source/cmExportInstallFileGenerator.cxx
index 954b5610b..02686f3d8 100644
--- a/Source/cmExportInstallFileGenerator.cxx
+++ b/Source/cmExportInstallFileGenerator.cxx
@@ -75,11 +75,12 @@ bool cmExportInstallFileGenerator::GenerateMainFile(std::ostream& os)
   // Create all the imported targets.
   for (cmTargetExport* te : allTargets) {
     cmGeneratorTarget* gt = te->Target;
+    cmStateEnums::TargetType targetType = this->GetExportTargetType(te);
 
     requiresConfigFiles =
-      requiresConfigFiles || gt->GetType() != cmStateEnums::INTERFACE_LIBRARY;
+      requiresConfigFiles || targetType != cmStateEnums::INTERFACE_LIBRARY;
 
-    this->GenerateImportTargetCode(os, gt);
+    this->GenerateImportTargetCode(os, gt, targetType);
 
     ImportPropertyMap properties;
 
@@ -103,6 +104,12 @@ bool cmExportInstallFileGenerator::GenerateMainFile(std::ostream& os)
                                     cmGeneratorExpression::InstallInterface,
                                     properties, missingTargets);
 
+    std::string errorMessage;
+    if (!this->PopulateExportProperties(gt, properties, errorMessage)) {
+      cmSystemTools::Error(errorMessage.c_str());
+      return false;
+    }
+
     const bool newCMP0022Behavior =
       gt->GetPolicyStatusCMP0022() != cmPolicies::WARN &&
       gt->GetPolicyStatusCMP0022() != cmPolicies::OLD;
@@ -114,7 +121,7 @@ bool cmExportInstallFileGenerator::GenerateMainFile(std::ostream& os)
         require2_8_12 = true;
       }
     }
-    if (gt->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
+    if (targetType == cmStateEnums::INTERFACE_LIBRARY) {
       require3_0_0 = true;
     }
     if (gt->GetProperty("INTERFACE_SOURCES")) {
@@ -308,7 +315,7 @@ void cmExportInstallFileGenerator::GenerateImportTargetsConfig(
   // Add each target in the set to the export.
   for (cmTargetExport* te : *this->IEGen->GetExportSet()->GetTargetExports()) {
     // Collect import properties for this target.
-    if (te->Target->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
+    if (this->GetExportTargetType(te) == cmStateEnums::INTERFACE_LIBRARY) {
       continue;
     }
 
@@ -340,7 +347,7 @@ void cmExportInstallFileGenerator::GenerateImportTargetsConfig(
                                    cmGeneratorExpression::InstallInterface,
                                    gtgt, properties, missingTargets);
 
-      // TOOD: PUBLIC_HEADER_LOCATION
+      // TODO: PUBLIC_HEADER_LOCATION
       // This should wait until the build feature propagation stuff
       // is done.  Then this can be a propagated include directory.
       // this->GenerateImportProperty(config, te->HeaderGenerator,
@@ -426,6 +433,19 @@ void cmExportInstallFileGenerator::SetImportLocationProperty(
   }
 }
 
+cmStateEnums::TargetType cmExportInstallFileGenerator::GetExportTargetType(
+  cmTargetExport const* targetExport) const
+{
+  cmStateEnums::TargetType targetType = targetExport->Target->GetType();
+  // An OBJECT library installed with no OBJECTS DESTINATION
+  // is transformed to an INTERFACE library.
+  if (targetType == cmStateEnums::OBJECT_LIBRARY &&
+      targetExport->ObjectsGenerator == nullptr) {
+    targetType = cmStateEnums::INTERFACE_LIBRARY;
+  }
+  return targetType;
+}
+
 void cmExportInstallFileGenerator::HandleMissingTarget(
   std::string& link_libs, std::vector<std::string>& missingTargets,
   cmGeneratorTarget* depender, cmGeneratorTarget* dependee)
diff --git a/Source/cmExportInstallFileGenerator.h b/Source/cmExportInstallFileGenerator.h
index cda8433a2..cbd650767 100644
--- a/Source/cmExportInstallFileGenerator.h
+++ b/Source/cmExportInstallFileGenerator.h
@@ -6,6 +6,7 @@
 #include "cmConfigure.h" // IWYU pragma: keep
 
 #include "cmExportFileGenerator.h"
+#include "cmStateTypes.h"
 
 #include <iosfwd>
 #include <map>
@@ -17,6 +18,7 @@ class cmGeneratorTarget;
 class cmGlobalGenerator;
 class cmInstallExportGenerator;
 class cmInstallTargetGenerator;
+class cmTargetExport;
 
 /** \class cmExportInstallFileGenerator
  * \brief Generate a file exporting targets from an install tree.
@@ -39,7 +41,7 @@ public:
       files.  */
   cmExportInstallFileGenerator(cmInstallExportGenerator* iegen);
 
-  /** Get the per-config file generated for each configuraiton.  This
+  /** Get the per-config file generated for each configuration.  This
       maps from the configuration name to the file temporary location
       for installation.  */
   std::map<std::string, std::string> const& GetConfigImportFiles()
@@ -57,6 +59,8 @@ protected:
   void GenerateImportTargetsConfig(
     std::ostream& os, const std::string& config, std::string const& suffix,
     std::vector<std::string>& missingTargets) override;
+  cmStateEnums::TargetType GetExportTargetType(
+    cmTargetExport const* targetExport) const;
   void HandleMissingTarget(std::string& link_libs,
                            std::vector<std::string>& missingTargets,
                            cmGeneratorTarget* depender,
diff --git a/Source/cmExportLibraryDependenciesCommand.h b/Source/cmExportLibraryDependenciesCommand.h
index bf5e9bc54..8414866a0 100644
--- a/Source/cmExportLibraryDependenciesCommand.h
+++ b/Source/cmExportLibraryDependenciesCommand.h
@@ -27,7 +27,7 @@ public:
 
 private:
   std::string Filename;
-  bool Append;
+  bool Append = false;
   void ConstFinalPass() const;
 };
 
diff --git a/Source/cmExportTryCompileFileGenerator.cxx b/Source/cmExportTryCompileFileGenerator.cxx
index ae8cd3743..87648cbb2 100644
--- a/Source/cmExportTryCompileFileGenerator.cxx
+++ b/Source/cmExportTryCompileFileGenerator.cxx
@@ -33,7 +33,7 @@ bool cmExportTryCompileFileGenerator::GenerateMainFile(std::ostream& os)
     this->Exports.pop_back();
     if (emitted.insert(te).second) {
       emittedDeps.insert(te);
-      this->GenerateImportTargetCode(os, te);
+      this->GenerateImportTargetCode(os, te, te->GetType());
 
       ImportPropertyMap properties;
 
diff --git a/Source/cmExportTryCompileFileGenerator.h b/Source/cmExportTryCompileFileGenerator.h
index ca2987caf..2a2ba7e50 100644
--- a/Source/cmExportTryCompileFileGenerator.h
+++ b/Source/cmExportTryCompileFileGenerator.h
@@ -26,6 +26,7 @@ public:
 
   /** Set the list of targets to export.  */
   void SetConfig(const std::string& config) { this->Config = config; }
+
 protected:
   // Implement virtual methods from the superclass.
   bool GenerateMainFile(std::ostream& os) override;
diff --git a/Source/cmExternalMakefileProjectGenerator.h b/Source/cmExternalMakefileProjectGenerator.h
index 5cc6442e7..d48abca78 100644
--- a/Source/cmExternalMakefileProjectGenerator.h
+++ b/Source/cmExternalMakefileProjectGenerator.h
@@ -62,7 +62,7 @@ protected:
   ///! Contains the names of the global generators support by this generator.
   std::vector<std::string> SupportedGlobalGenerators;
   ///! the global generator which creates the makefiles
-  const cmGlobalGenerator* GlobalGenerator;
+  const cmGlobalGenerator* GlobalGenerator = nullptr;
 
   std::string Name;
 };
diff --git a/Source/cmExtraCodeBlocksGenerator.cxx b/Source/cmExtraCodeBlocksGenerator.cxx
index 4b95140ad..b636c736d 100644
--- a/Source/cmExtraCodeBlocksGenerator.cxx
+++ b/Source/cmExtraCodeBlocksGenerator.cxx
@@ -337,7 +337,7 @@ void cmExtraCodeBlocksGenerator::CreateNewProjectFile(
   xml.EndElement(); // Build
 
   // Collect all used source files in the project.
-  // Keep a list of C/C++ source files which might have an acompanying header
+  // Keep a list of C/C++ source files which might have an accompanying header
   // that should be looked for.
   typedef std::map<std::string, CbpUnit> all_files_map_t;
   all_files_map_t allFiles;
@@ -614,23 +614,27 @@ void cmExtraCodeBlocksGenerator::AppendTarget(
   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
diff --git a/Source/cmExtraCodeLiteGenerator.cxx b/Source/cmExtraCodeLiteGenerator.cxx
index 4dbaa3f41..b76efb2ff 100644
--- a/Source/cmExtraCodeLiteGenerator.cxx
+++ b/Source/cmExtraCodeLiteGenerator.cxx
@@ -265,7 +265,7 @@ void cmExtraCodeLiteGenerator::CreateNewProjectFile(
 
   // Collect all used source files in the project
   // Sort them into two containers, one for C/C++ implementation files
-  // which may have an acompanying header, one for all other files
+  // which may have an accompanying header, one for all other files
   std::map<std::string, cmSourceFile*> cFiles;
   std::set<std::string> otherFiles;
 
@@ -408,7 +408,6 @@ void cmExtraCodeLiteGenerator::CreateProjectSourceEntries(
   const std::string& projectPath, const cmMakefile* mf,
   const std::string& projectType, const std::string& targetName)
 {
-
   cmXMLWriter& xml(*_xml);
   FindMatchingHeaderfiles(cFiles, otherFiles);
   // Create 2 virtual folders: src and include
@@ -469,10 +468,14 @@ void cmExtraCodeLiteGenerator::CreateProjectSourceEntries(
   xml.EndElement(); // ResourceCompiler
 
   xml.StartElement("General");
-  std::string outputPath = mf->GetSafeDefinition("EXECUTABLE_OUTPUT_PATH");
+  std::string outputPath =
+    mf->GetSafeDefinition("CMAKE_RUNTIME_OUTPUT_DIRECTORY");
+  if (outputPath.empty()) {
+    outputPath = mf->GetSafeDefinition("EXECUTABLE_OUTPUT_PATH");
+  }
   std::string relapath;
   if (!outputPath.empty()) {
-    relapath = cmSystemTools::RelativePath(this->WorkspacePath, outputPath);
+    relapath = cmSystemTools::RelativePath(projectPath, outputPath);
     xml.Attribute("OutputFile", relapath + "/$(ProjectName)");
   } else {
     xml.Attribute("OutputFile", "$(IntermediateDirectory)/$(ProjectName)");
@@ -568,7 +571,7 @@ void cmExtraCodeLiteGenerator::CreateNewProjectFile(
 
   // Collect all used source files in the project
   // Sort them into two containers, one for C/C++ implementation files
-  // which may have an acompanying header, one for all other files
+  // which may have an accompanying header, one for all other files
   std::string projectType;
 
   std::map<std::string, cmSourceFile*> cFiles;
@@ -635,7 +638,7 @@ std::string cmExtraCodeLiteGenerator::GetBuildCommand(
   if (generator == "NMake Makefiles" || generator == "Ninja") {
     ss << make;
   } else if (generator == "MinGW Makefiles" || generator == "Unix Makefiles") {
-    ss << make << " -j " << this->CpuCount;
+    ss << make << " -f$(ProjectPath)/Makefile -j " << this->CpuCount;
   }
   if (!targetName.empty()) {
     ss << " " << targetName;
diff --git a/Source/cmExtraEclipseCDT4Generator.cxx b/Source/cmExtraEclipseCDT4Generator.cxx
index 258c9ca26..14448f578 100644
--- a/Source/cmExtraEclipseCDT4Generator.cxx
+++ b/Source/cmExtraEclipseCDT4Generator.cxx
@@ -277,10 +277,11 @@ void cmExtraEclipseCDT4Generator::CreateProjectFile()
   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", "");
@@ -641,7 +642,8 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
       xml.EndElement(); // extension
     } else if (systemName == "Darwin") {
       xml.StartElement("extension");
-      xml.Attribute("id", this->SupportsMachO64Parser
+      xml.Attribute("id",
+                    this->SupportsMachO64Parser
                       ? "org.eclipse.cdt.core.MachO64"
                       : "org.eclipse.cdt.core.MachO");
       xml.Attribute("point", "org.eclipse.cdt.core.BinaryParser");
@@ -1001,6 +1003,13 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
   xml.EndElement(); // project
 
   xml.EndElement(); // storageModule
+
+  // Append additional cproject contents without applying any XML formatting
+  if (const char* extraCProjectContents =
+        mf->GetState()->GetGlobalProperty("ECLIPSE_EXTRA_CPROJECT_CONTENTS")) {
+    fout << extraCProjectContents;
+  }
+
   xml.EndElement(); // cproject
 }
 
diff --git a/Source/cmExtraKateGenerator.cxx b/Source/cmExtraKateGenerator.cxx
index 7a83e4148..df1871536 100644
--- a/Source/cmExtraKateGenerator.cxx
+++ b/Source/cmExtraKateGenerator.cxx
@@ -199,8 +199,9 @@ void cmExtraKateGenerator::AppendTarget(cmGeneratedFileStream& fout,
 {
   static char JsonSep = ' ';
 
-  fout << "\t\t\t" << JsonSep << "{\"name\":\"" << target << "\", "
-                                                             "\"build_cmd\":\""
+  fout << "\t\t\t" << JsonSep << "{\"name\":\"" << target
+       << "\", "
+          "\"build_cmd\":\""
        << make << " -C \\\"" << (this->UseNinja ? homeOutputDir : path)
        << "\\\" " << makeArgs << " " << target << "\"}\n";
 
diff --git a/Source/cmExtraSublimeTextGenerator.cxx b/Source/cmExtraSublimeTextGenerator.cxx
index 46dcaf649..fb85a6882 100644
--- a/Source/cmExtraSublimeTextGenerator.cxx
+++ b/Source/cmExtraSublimeTextGenerator.cxx
@@ -400,8 +400,9 @@ std::string cmExtraSublimeTextGenerator::ComputeDefines(
   std::string defPropName = "COMPILE_DEFINITIONS_";
   defPropName += cmSystemTools::UpperCase(config);
   if (const char* config_compile_defs = source->GetProperty(defPropName)) {
-    lg->AppendDefines(defines, genexInterpreter.Evaluate(config_compile_defs,
-                                                         COMPILE_DEFINITIONS));
+    lg->AppendDefines(
+      defines,
+      genexInterpreter.Evaluate(config_compile_defs, COMPILE_DEFINITIONS));
   }
 
   std::string definesString;
diff --git a/Source/cmFileCommand.cxx b/Source/cmFileCommand.cxx
index d3dcc0112..dcb79f7dd 100644
--- a/Source/cmFileCommand.cxx
+++ b/Source/cmFileCommand.cxx
@@ -36,17 +36,17 @@
 #include "cmake.h"
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
-#include "cmCurl.h"
-#include "cmFileLockResult.h"
-#include "cm_curl.h"
+#  include "cmCurl.h"
+#  include "cmFileLockResult.h"
+#  include "cm_curl.h"
 #endif
 
 #if defined(CMAKE_USE_ELF_PARSER)
-#include "cmELF.h"
+#  include "cmELF.h"
 #endif
 
 #if defined(_WIN32)
-#include <windows.h>
+#  include <windows.h>
 #endif
 
 class cmSystemToolsFileTime;
@@ -160,6 +160,12 @@ bool cmFileCommand::InitialPass(std::vector<std::string> const& args,
   if (subCommand == "TO_NATIVE_PATH") {
     return this->HandleCMakePathCommand(args, true);
   }
+  if (subCommand == "TOUCH") {
+    return this->HandleTouchCommand(args, true);
+  }
+  if (subCommand == "TOUCH_NOCREATE") {
+    return this->HandleTouchCommand(args, false);
+  }
   if (subCommand == "TIMESTAMP") {
     return this->HandleTimestampCommand(args);
   }
@@ -210,7 +216,7 @@ bool cmFileCommand::HandleWriteCommand(std::vector<std::string> const& args,
 #else
                                   mode | S_IWUSR | S_IWGRP
 #endif
-                                  );
+    );
   }
   // If GetPermissions fails, pretend like it is ok. File open will fail if
   // the file is not writable
@@ -226,6 +232,14 @@ bool cmFileCommand::HandleWriteCommand(std::vector<std::string> const& args,
   }
   std::string message = cmJoin(cmMakeRange(i, args.end()), std::string());
   file << message;
+  if (!file) {
+    std::string error = "write failed (";
+    error += cmSystemTools::GetLastSystemError();
+    error += "):\n  ";
+    error += fileName;
+    this->SetError(error);
+    return false;
+  }
   file.close();
   if (mode) {
     cmSystemTools::SetPermissions(fileName.c_str(), mode);
@@ -268,7 +282,8 @@ bool cmFileCommand::HandleReadCommand(std::vector<std::string> const& args)
 // Open the specified file.
 #if defined(_WIN32) || defined(__CYGWIN__)
   cmsys::ifstream file(
-    fileName.c_str(), std::ios::in |
+    fileName.c_str(),
+    std::ios::in |
       (hexOutputArg.IsEnabled() ? std::ios::binary : std::ios::in));
 #else
   cmsys::ifstream file(fileName.c_str());
@@ -313,8 +328,9 @@ bool cmFileCommand::HandleReadCommand(std::vector<std::string> const& args)
   } else {
     std::string line;
     bool has_newline = false;
-    while (sizeLimit != 0 && cmSystemTools::GetLineFromStream(
-                               file, line, &has_newline, sizeLimit)) {
+    while (
+      sizeLimit != 0 &&
+      cmSystemTools::GetLineFromStream(file, line, &has_newline, sizeLimit)) {
       if (sizeLimit > 0) {
         sizeLimit = sizeLimit - static_cast<long>(line.size());
         if (has_newline) {
@@ -602,7 +618,9 @@ bool cmFileCommand::HandleStringsCommand(std::vector<std::string> const& args)
     } 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 },
+        { 0xE0, 0xC0 },
+        { 0xF0, 0xE0 },
+        { 0xF8, 0xF0 },
       };
 
       // how many octets are there?
@@ -751,11 +769,15 @@ bool cmFileCommand::HandleGlobCommand(std::vector<std::string> const& args,
     }
   }
 
-  std::string output;
-  bool first = true;
-  for (; i != args.end(); ++i) {
+  std::vector<std::string> files;
+  bool configureDepends = false;
+  bool warnConfigureLate = false;
+  bool warnFollowedSymlinks = false;
+  const cmake::WorkingMode workingMode =
+    this->Makefile->GetCMakeInstance()->GetWorkingMode();
+  while (i != args.end()) {
     if (*i == "LIST_DIRECTORIES") {
-      ++i;
+      ++i; // skip LIST_DIRECTORIES
       if (i != args.end()) {
         if (cmSystemTools::IsOn(i->c_str())) {
           g.SetListDirs(true);
@@ -767,107 +789,138 @@ bool cmFileCommand::HandleGlobCommand(std::vector<std::string> const& args,
           this->SetError("LIST_DIRECTORIES missing bool value.");
           return false;
         }
+        ++i;
       } else {
         this->SetError("LIST_DIRECTORIES missing bool value.");
         return false;
       }
-      continue;
-    }
-
-    if (recurse && (*i == "FOLLOW_SYMLINKS")) {
-      explicitFollowSymlinks = true;
-      g.RecurseThroughSymlinksOn();
-      ++i;
-      if (i == args.end()) {
-        this->SetError(
-          "GLOB_RECURSE requires a glob expression after FOLLOW_SYMLINKS");
-        return false;
+    } else if (*i == "FOLLOW_SYMLINKS") {
+      ++i; // skip FOLLOW_SYMLINKS
+      if (recurse) {
+        explicitFollowSymlinks = true;
+        g.RecurseThroughSymlinksOn();
+        if (i == args.end()) {
+          this->SetError(
+            "GLOB_RECURSE requires a glob expression after FOLLOW_SYMLINKS.");
+          return false;
+        }
       }
-    }
-
-    if (*i == "RELATIVE") {
+    } else if (*i == "RELATIVE") {
       ++i; // skip RELATIVE
       if (i == args.end()) {
-        this->SetError("GLOB requires a directory after the RELATIVE tag");
+        this->SetError("GLOB requires a directory after the RELATIVE tag.");
         return false;
       }
       g.SetRelative(i->c_str());
       ++i;
       if (i == args.end()) {
-        this->SetError("GLOB requires a glob expression after the directory");
+        this->SetError("GLOB requires a glob expression after the directory.");
         return false;
       }
-    }
-
-    cmsys::Glob::GlobMessages globMessages;
-    if (!cmsys::SystemTools::FileIsFullPath(*i)) {
-      std::string expr = this->Makefile->GetCurrentSourceDirectory();
-      // Handle script mode
-      if (!expr.empty()) {
-        expr += "/" + *i;
-        g.FindFiles(expr, &globMessages);
-      } else {
-        g.FindFiles(*i, &globMessages);
+    } else if (*i == "CONFIGURE_DEPENDS") {
+      // Generated build system depends on glob results
+      if (!configureDepends && warnConfigureLate) {
+        this->Makefile->IssueMessage(
+          cmake::AUTHOR_WARNING,
+          "CONFIGURE_DEPENDS flag was given after a glob expression was "
+          "already evaluated.");
+      }
+      if (workingMode != cmake::NORMAL_MODE) {
+        this->Makefile->IssueMessage(
+          cmake::FATAL_ERROR,
+          "CONFIGURE_DEPENDS is invalid for script and find package modes.");
+        return false;
+      }
+      configureDepends = true;
+      ++i;
+      if (i == args.end()) {
+        this->SetError(
+          "GLOB requires a glob expression after CONFIGURE_DEPENDS.");
+        return false;
       }
     } else {
-      g.FindFiles(*i, &globMessages);
-    }
-
-    if (!globMessages.empty()) {
-      bool shouldExit = false;
-      for (cmsys::Glob::Message const& globMessage : globMessages) {
-        if (globMessage.type == cmsys::Glob::cyclicRecursion) {
-          this->Makefile->IssueMessage(
-            cmake::AUTHOR_WARNING,
-            "Cyclic recursion detected while globbing for '" + *i + "':\n" +
-              globMessage.content);
+      std::string expr = *i;
+      if (!cmsys::SystemTools::FileIsFullPath(*i)) {
+        expr = this->Makefile->GetCurrentSourceDirectory();
+        // Handle script mode
+        if (!expr.empty()) {
+          expr += "/" + *i;
         } else {
-          this->Makefile->IssueMessage(
-            cmake::FATAL_ERROR, "Error has occurred while globbing for '" +
-              *i + "' - " + globMessage.content);
-          shouldExit = true;
+          expr = *i;
         }
       }
-      if (shouldExit) {
-        return false;
+
+      cmsys::Glob::GlobMessages globMessages;
+      g.FindFiles(expr, &globMessages);
+
+      if (!globMessages.empty()) {
+        bool shouldExit = false;
+        for (cmsys::Glob::Message const& globMessage : globMessages) {
+          if (globMessage.type == cmsys::Glob::cyclicRecursion) {
+            this->Makefile->IssueMessage(
+              cmake::AUTHOR_WARNING,
+              "Cyclic recursion detected while globbing for '" + *i + "':\n" +
+                globMessage.content);
+          } else {
+            this->Makefile->IssueMessage(
+              cmake::FATAL_ERROR,
+              "Error has occurred while globbing for '" + *i + "' - " +
+                globMessage.content);
+            shouldExit = true;
+          }
+        }
+        if (shouldExit) {
+          return false;
+        }
       }
-    }
 
-    std::vector<std::string>::size_type cc;
-    std::vector<std::string>& files = g.GetFiles();
-    std::sort(files.begin(), files.end());
-    for (cc = 0; cc < files.size(); cc++) {
-      if (!first) {
-        output += ";";
+      if (recurse && !explicitFollowSymlinks &&
+          g.GetFollowedSymlinkCount() != 0) {
+        warnFollowedSymlinks = true;
       }
-      output += files[cc];
-      first = false;
+
+      std::vector<std::string>& foundFiles = g.GetFiles();
+      files.insert(files.end(), foundFiles.begin(), foundFiles.end());
+
+      if (configureDepends) {
+        std::sort(foundFiles.begin(), foundFiles.end());
+        foundFiles.erase(std::unique(foundFiles.begin(), foundFiles.end()),
+                         foundFiles.end());
+        this->Makefile->GetCMakeInstance()->AddGlobCacheEntry(
+          recurse, (recurse ? g.GetRecurseListDirs() : g.GetListDirs()),
+          (recurse ? g.GetRecurseThroughSymlinks() : false),
+          (g.GetRelative() ? g.GetRelative() : ""), expr, foundFiles, variable,
+          this->Makefile->GetBacktrace());
+      } else {
+        warnConfigureLate = true;
+      }
+      ++i;
     }
   }
 
-  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.
-      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,
-            cmPolicies::GetPolicyWarning(cmPolicies::CMP0009));
-        }
-        break;
-    }
+  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.
+    case cmPolicies::WARN:
+      // Possibly unexpected old behavior *and* we actually traversed
+      // symlinks without being explicitly asked to: warn the author.
+      if (warnFollowedSymlinks) {
+        this->Makefile->IssueMessage(
+          cmake::AUTHOR_WARNING,
+          cmPolicies::GetPolicyWarning(cmPolicies::CMP0009));
+      }
+      break;
   }
 
-  this->Makefile->AddDefinition(variable, output.c_str());
+  std::sort(files.begin(), files.end());
+  files.erase(std::unique(files.begin(), files.end()), files.end());
+  this->Makefile->AddDefinition(variable, cmJoin(files, ";").c_str());
   return true;
 }
 
@@ -905,6 +958,38 @@ bool cmFileCommand::HandleMakeDirectoryCommand(
   return true;
 }
 
+bool cmFileCommand::HandleTouchCommand(std::vector<std::string> const& args,
+                                       bool create)
+{
+  // File command has at least one argument
+  assert(args.size() > 1);
+
+  std::vector<std::string>::const_iterator i = args.begin();
+
+  i++; // Get rid of subcommand
+
+  for (; i != args.end(); ++i) {
+    std::string tfile = *i;
+    if (!cmsys::SystemTools::FileIsFullPath(tfile)) {
+      tfile = this->Makefile->GetCurrentSourceDirectory();
+      tfile += "/" + *i;
+    }
+    if (!this->Makefile->CanIWriteThisFile(tfile)) {
+      std::string e =
+        "attempted to touch a file: " + tfile + " in a source directory.";
+      this->SetError(e);
+      cmSystemTools::SetFatalErrorOccured();
+      return false;
+    }
+    if (!cmSystemTools::Touch(tfile, create)) {
+      std::string error = "problem touching file: " + tfile;
+      this->SetError(error);
+      return false;
+    }
+  }
+  return true;
+}
+
 bool cmFileCommand::HandleDifferentCommand(
   std::vector<std::string> const& args)
 {
@@ -1051,14 +1136,26 @@ protected:
     if (permissions) {
 #ifdef WIN32
       if (Makefile->IsOn("CMAKE_CROSSCOMPILING")) {
+        // Store the mode in an NTFS alternate stream.
         std::string mode_t_adt_filename =
           std::string(toFile) + ":cmake_mode_t";
 
+        // Writing to an NTFS alternate stream changes the modification
+        // time, so we need to save and restore its original value.
+        cmSystemToolsFileTime* file_time_orig = cmSystemTools::FileTimeNew();
+        cmSystemTools::FileTimeGet(toFile, file_time_orig);
+
         cmsys::ofstream permissionStream(mode_t_adt_filename.c_str());
 
         if (permissionStream) {
           permissionStream << std::oct << permissions << std::endl;
         }
+
+        permissionStream.close();
+
+        cmSystemTools::FileTimeSet(toFile, file_time_orig);
+
+        cmSystemTools::FileTimeDelete(file_time_orig);
       }
 #endif
 
@@ -2768,9 +2865,9 @@ bool cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
     return false;
   }
 
-#if defined(_WIN32)
+#  if defined(_WIN32)
   url = fix_file_url_windows(url);
-#endif
+#  endif
 
   ::CURL* curl;
   ::curl_global_init(CURL_GLOBAL_DEFAULT);
@@ -3057,9 +3154,9 @@ bool cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args)
 
   unsigned long file_size = cmsys::SystemTools::FileLength(filename);
 
-#if defined(_WIN32)
+#  if defined(_WIN32)
   url = fix_file_url_windows(url);
-#endif
+#  endif
 
   ::CURL* curl;
   ::curl_global_init(CURL_GLOBAL_DEFAULT);
diff --git a/Source/cmFileCommand.h b/Source/cmFileCommand.h
index 17269f3f9..719dca29e 100644
--- a/Source/cmFileCommand.h
+++ b/Source/cmFileCommand.h
@@ -39,6 +39,7 @@ protected:
   bool HandleHashCommand(std::vector<std::string> const& args);
   bool HandleStringsCommand(std::vector<std::string> const& args);
   bool HandleGlobCommand(std::vector<std::string> const& args, bool recurse);
+  bool HandleTouchCommand(std::vector<std::string> const& args, bool create);
   bool HandleMakeDirectoryCommand(std::vector<std::string> const& args);
 
   bool HandleRelativePathCommand(std::vector<std::string> const& args);
diff --git a/Source/cmFileLock.cxx b/Source/cmFileLock.cxx
index f309241a6..1e472da63 100644
--- a/Source/cmFileLock.cxx
+++ b/Source/cmFileLock.cxx
@@ -54,7 +54,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 c9ab0dbcb..6c9a7b86f 100644
--- a/Source/cmFileLock.h
+++ b/Source/cmFileLock.h
@@ -8,17 +8,17 @@
 #include <string>
 
 #if defined(_WIN32)
-#include <windows.h> // HANDLE
+#  include <windows.h> // HANDLE
 #endif
 
 class cmFileLockResult;
 
 /**
-  * @brief Cross-platform file locking.
-  * @details Under the hood this class use 'fcntl' for Unix-like platforms and
-  * 'LockFileEx'/'UnlockFileEx' for Win32 platform. Locks are exclusive and
-  * advisory.
-  */
+ * @brief Cross-platform file locking.
+ * @details Under the hood this class use 'fcntl' for Unix-like platforms and
+ * 'LockFileEx'/'UnlockFileEx' for Win32 platform. Locks are exclusive and
+ * advisory.
+ */
 class cmFileLock
 {
   CM_DISABLE_COPY(cmFileLock)
@@ -28,21 +28,21 @@ public:
   ~cmFileLock();
 
   /**
-    * @brief Lock the file.
-    * @param timeoutSec Lock timeout. If -1 try until success or fatal error.
-    */
+   * @brief Lock the file.
+   * @param timeoutSec Lock timeout. If -1 try until success or fatal error.
+   */
   cmFileLockResult Lock(const std::string& filename, unsigned long timeoutSec);
 
   /**
-    * @brief Unlock the file.
-    */
+   * @brief Unlock the file.
+   */
   cmFileLockResult Release();
 
   /**
-    * @brief Check file is locked by this class.
-    * @details This function helps to find double locks (deadlocks) and to do
-    * explicit unlocks.
-    */
+   * @brief Check file is locked by this class.
+   * @details This function helps to find double locks (deadlocks) and to do
+   * explicit unlocks.
+   */
   bool IsLocked(const std::string& filename) const;
 
 private:
diff --git a/Source/cmFileLockPool.h b/Source/cmFileLockPool.h
index af982707e..0197354c3 100644
--- a/Source/cmFileLockPool.h
+++ b/Source/cmFileLockPool.h
@@ -21,25 +21,25 @@ public:
 
   //@{
   /**
-    * @brief Function scope control.
-    */
+   * @brief Function scope control.
+   */
   void PushFunctionScope();
   void PopFunctionScope();
   //@}
 
   //@{
   /**
-    * @brief File scope control.
-    */
+   * @brief File scope control.
+   */
   void PushFileScope();
   void PopFileScope();
   //@}
 
   //@{
   /**
-    * @brief Lock the file in given scope.
-    * @param timeoutSec Lock timeout. If -1 try until success or fatal error.
-    */
+   * @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,
@@ -49,8 +49,8 @@ public:
   //@}
 
   /**
-    * @brief Unlock the file explicitly.
-    */
+   * @brief Unlock the file explicitly.
+   */
   cmFileLockResult Release(const std::string& filename);
 
 private:
diff --git a/Source/cmFileLockResult.h b/Source/cmFileLockResult.h
index 4cedc0ae6..8b4929ae1 100644
--- a/Source/cmFileLockResult.h
+++ b/Source/cmFileLockResult.h
@@ -8,13 +8,13 @@
 #include <string>
 
 #if defined(_WIN32)
-#include <windows.h> // DWORD
+#  include <windows.h> // DWORD
 #endif
 
 /**
-  * @brief Result of the locking/unlocking file.
-  * @note See @c cmFileLock
-  */
+ * @brief Result of the locking/unlocking file.
+ * @note See @c cmFileLock
+ */
 class cmFileLockResult
 {
 public:
@@ -25,33 +25,33 @@ public:
 #endif
 
   /**
-    * @brief Successful lock/unlock.
-    */
+   * @brief Successful lock/unlock.
+   */
   static cmFileLockResult MakeOk();
 
   /**
-    * @brief Lock/Unlock failed. Read error/GetLastError.
-    */
+   * @brief Lock/Unlock failed. Read error/GetLastError.
+   */
   static cmFileLockResult MakeSystem();
 
   /**
-    * @brief Lock/Unlock failed. Timeout reached.
-    */
+   * @brief Lock/Unlock failed. Timeout reached.
+   */
   static cmFileLockResult MakeTimeout();
 
   /**
-    * @brief File already locked.
-    */
+   * @brief File already locked.
+   */
   static cmFileLockResult MakeAlreadyLocked();
 
   /**
-    * @brief Internal error.
-    */
+   * @brief Internal error.
+   */
   static cmFileLockResult MakeInternal();
 
   /**
-    * @brief Try to lock with function guard outside of the function
-    */
+   * @brief Try to lock with function guard outside of the function
+   */
   static cmFileLockResult MakeNoFunction();
 
   bool IsOk() const;
diff --git a/Source/cmFileTimeComparison.cxx b/Source/cmFileTimeComparison.cxx
index 622c15e2c..8f6993d1e 100644
--- a/Source/cmFileTimeComparison.cxx
+++ b/Source/cmFileTimeComparison.cxx
@@ -9,12 +9,12 @@
 
 // Use a platform-specific API to get file times efficiently.
 #if !defined(_WIN32) || defined(__CYGWIN__)
-#include "cm_sys_stat.h"
-#define cmFileTimeComparison_Type struct stat
+#  include "cm_sys_stat.h"
+#  define cmFileTimeComparison_Type struct stat
 #else
-#include "cmsys/Encoding.hxx"
-#include <windows.h>
-#define cmFileTimeComparison_Type FILETIME
+#  include "cmsys/Encoding.hxx"
+#  include <windows.h>
+#  define cmFileTimeComparison_Type FILETIME
 #endif
 
 class cmFileTimeComparisonInternal
@@ -98,7 +98,7 @@ 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) {
     return -1;
@@ -112,7 +112,7 @@ int cmFileTimeComparisonInternal::Compare(cmFileTimeComparison_Type* s1,
   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) {
     return -1;
@@ -126,7 +126,7 @@ int cmFileTimeComparisonInternal::Compare(cmFileTimeComparison_Type* s1,
   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) {
     return -1;
@@ -134,7 +134,7 @@ int cmFileTimeComparisonInternal::Compare(cmFileTimeComparison_Type* s1,
   if (s1->st_mtime > s2->st_mtime) {
     return 1;
   }
-#endif
+#  endif
   // Files have the same time.
   return 0;
 #else
@@ -147,7 +147,7 @@ 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;
@@ -159,7 +159,7 @@ bool cmFileTimeComparisonInternal::TimesDiffer(cmFileTimeComparison_Type* s1,
     return (t1 - t2) >= bil;
   }
   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;
@@ -171,7 +171,7 @@ bool cmFileTimeComparisonInternal::TimesDiffer(cmFileTimeComparison_Type* s1,
     return (t1 - t2) >= bil;
   }
   return false;
-#else
+#  else
   // Times are integers in units of 1s.
   if (s1->st_mtime < s2->st_mtime) {
     return (s2->st_mtime - s1->st_mtime) >= 1;
@@ -180,7 +180,7 @@ bool cmFileTimeComparisonInternal::TimesDiffer(cmFileTimeComparison_Type* s1,
     return (s1->st_mtime - s2->st_mtime) >= 1;
   }
   return false;
-#endif
+#  endif
 #else
   // Times are integers in units of 100ns.
   LARGE_INTEGER t1;
diff --git a/Source/cmFileTimeComparison.h b/Source/cmFileTimeComparison.h
index b1f8ed636..114989b51 100644
--- a/Source/cmFileTimeComparison.h
+++ b/Source/cmFileTimeComparison.h
@@ -8,9 +8,9 @@
 class cmFileTimeComparisonInternal;
 
 /** \class cmFileTimeComparison
- * \brief Helper class for performing globbing searches.
+ * \brief Helper class for comparing file modification times.
  *
- * Finds all files that match a given globbing expression.
+ * Compare file modification times or test if file modification times differ.
  */
 class cmFileTimeComparison
 {
diff --git a/Source/cmFindBase.cxx b/Source/cmFindBase.cxx
index 417cdd25c..865595b79 100644
--- a/Source/cmFindBase.cxx
+++ b/Source/cmFindBase.cxx
@@ -67,8 +67,6 @@ bool cmFindBase::ParseArguments(std::vector<std::string> const& argsIn)
   }
   this->AlreadyInCache = false;
 
-  this->SelectDefaultNoPackageRootPath();
-
   // Find the current root path mode.
   this->SelectDefaultRootPathMode();
 
@@ -206,16 +204,12 @@ void cmFindBase::FillPackageRootPath()
 {
   cmSearchPath& paths = this->LabeledPaths[PathLabel::PackageRoot];
 
-  // Add package specific search prefixes
-  // NOTE: This should be using const_reverse_iterator but HP aCC and
-  //       Oracle sunCC both currently have standard library issues
-  //       with the reverse iterator APIs.
-  for (std::deque<std::string>::reverse_iterator pkg =
-         this->Makefile->FindPackageModuleStack.rbegin();
-       pkg != this->Makefile->FindPackageModuleStack.rend(); ++pkg) {
-    std::string varName = *pkg + "_ROOT";
-    paths.AddCMakePrefixPath(varName);
-    paths.AddEnvPrefixPath(varName);
+  // Add the PACKAGE_ROOT_PATH from each enclosing find_package call.
+  for (std::deque<std::vector<std::string>>::const_reverse_iterator pkgPaths =
+         this->Makefile->FindPackageRootPathStack.rbegin();
+       pkgPaths != this->Makefile->FindPackageRootPathStack.rend();
+       ++pkgPaths) {
+    paths.AddPrefixPaths(*pkgPaths);
   }
 
   paths.AddSuffixes(this->SearchPathSuffixes);
@@ -225,8 +219,8 @@ void cmFindBase::FillCMakeVariablePath()
 {
   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
+  // Add CMake variables of the same name as the previous environment
+  // variables CMAKE_*_PATH to be used most of the time with -D
   // command line options
   std::string var = "CMAKE_";
   var += this->CMakePathName;
diff --git a/Source/cmFindCommon.cxx b/Source/cmFindCommon.cxx
index 4a467f384..fbaacfcf5 100644
--- a/Source/cmFindCommon.cxx
+++ b/Source/cmFindCommon.cxx
@@ -56,7 +56,7 @@ void cmFindCommon::InitializeSearchPathGroups()
 {
   std::vector<PathLabel>* labels;
 
-  // Define the varoius different groups of path types
+  // Define the various different groups of path types
 
   // All search paths
   labels = &this->PathGroupLabelMap[PathGroup::All];
@@ -71,7 +71,7 @@ void cmFindCommon::InitializeSearchPathGroups()
   // Define the search group order
   this->PathGroupOrder.push_back(PathGroup::All);
 
-  // Create the idividual labeld search paths
+  // Create the individual labeled search paths
   this->LabeledPaths.insert(
     std::make_pair(PathLabel::PackageRoot, cmSearchPath(this)));
   this->LabeledPaths.insert(
@@ -88,13 +88,6 @@ void cmFindCommon::InitializeSearchPathGroups()
     std::make_pair(PathLabel::Guess, cmSearchPath(this)));
 }
 
-void cmFindCommon::SelectDefaultNoPackageRootPath()
-{
-  if (!this->Makefile->IsOn("__UNDOCUMENTED_CMAKE_FIND_PACKAGE_ROOT")) {
-    this->NoPackageRootPath = true;
-  }
-}
-
 void cmFindCommon::SelectDefaultRootPathMode()
 {
   // Check the policy variable for this find command type.
diff --git a/Source/cmFindCommon.h b/Source/cmFindCommon.h
index b237f1bd1..89ff1741d 100644
--- a/Source/cmFindCommon.h
+++ b/Source/cmFindCommon.h
@@ -84,9 +84,6 @@ protected:
   /** Compute final search path list (reroot + trailing slash).  */
   void ComputeFinalPaths();
 
-  /** Decide whether to enable the PACKAGE_ROOT search entries.  */
-  void SelectDefaultNoPackageRootPath();
-
   /** Compute the current default root path mode.  */
   void SelectDefaultRootPathMode();
 
diff --git a/Source/cmFindPackageCommand.cxx b/Source/cmFindPackageCommand.cxx
index 2f3a85b07..7ac0cdff0 100644
--- a/Source/cmFindPackageCommand.cxx
+++ b/Source/cmFindPackageCommand.cxx
@@ -21,6 +21,7 @@
 
 #include "cmAlgorithms.h"
 #include "cmMakefile.h"
+#include "cmPolicies.h"
 #include "cmSearchPath.h"
 #include "cmState.h"
 #include "cmStateTypes.h"
@@ -28,8 +29,8 @@
 #include "cmake.h"
 
 #if defined(__HAIKU__)
-#include <FindDirectory.h>
-#include <StorageDefs.h>
+#  include <FindDirectory.h>
+#  include <StorageDefs.h>
 #endif
 
 class cmExecutionStatus;
@@ -209,8 +210,6 @@ bool cmFindPackageCommand::InitialPass(std::vector<std::string> const& args,
     this->SortDirection = strcmp(sd, "ASC") == 0 ? Asc : Dec;
   }
 
-  this->SelectDefaultNoPackageRootPath();
-
   // Find the current root path mode.
   this->SelectDefaultRootPathMode();
 
@@ -454,6 +453,38 @@ bool cmFindPackageCommand::InitialPass(std::vector<std::string> const& args,
     return true;
   }
 
+  {
+    // Allocate a PACKAGE_ROOT_PATH for the current find_package call.
+    this->Makefile->FindPackageRootPathStack.emplace_back();
+    std::vector<std::string>& rootPaths =
+      *this->Makefile->FindPackageRootPathStack.rbegin();
+
+    // Add root paths from <PackageName>_ROOT CMake and environment variables,
+    // subject to CMP0074.
+    switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0074)) {
+      case cmPolicies::WARN:
+        this->Makefile->MaybeWarnCMP0074(this->Name);
+        CM_FALLTHROUGH;
+      case cmPolicies::OLD:
+        // OLD behavior is to ignore the <pkg>_ROOT variables.
+        break;
+      case cmPolicies::REQUIRED_IF_USED:
+      case cmPolicies::REQUIRED_ALWAYS:
+        this->Makefile->IssueMessage(
+          cmake::FATAL_ERROR,
+          cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0074));
+        break;
+      case cmPolicies::NEW: {
+        // NEW behavior is to honor the <pkg>_ROOT variables.
+        std::string const rootVar = this->Name + "_ROOT";
+        if (const char* pkgRoot = this->Makefile->GetDefinition(rootVar)) {
+          cmSystemTools::ExpandListArgument(pkgRoot, rootPaths, false);
+        }
+        cmSystemTools::GetPath(rootPaths, rootVar.c_str());
+      } break;
+    }
+  }
+
   this->SetModuleVariables(components);
 
   // See if there is a Find<package>.cmake module.
@@ -494,10 +525,12 @@ bool cmFindPackageCommand::InitialPass(std::vector<std::string> const& args,
            "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.";
+        << 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.)";
@@ -589,9 +622,6 @@ void cmFindPackageCommand::SetModuleVariables(const std::string& components)
     exact += "_FIND_VERSION_EXACT";
     this->AddFindDefinition(exact, this->VersionExact ? "1" : "0");
   }
-
-  // Push on to the package stack
-  this->Makefile->FindPackageModuleStack.push_back(this->Name);
 }
 
 void cmFindPackageCommand::AddFindDefinition(const std::string& var,
@@ -736,8 +766,9 @@ bool cmFindPackageCommand::HandlePackageMode()
   if (result && !found) {
     // warn if package required or neither quiet nor in config mode
     if (this->Required ||
-        !(this->Quiet || (this->UseConfigFiles && !this->UseFindModules &&
-                          this->ConsideredConfigs.empty()))) {
+        !(this->Quiet ||
+          (this->UseConfigFiles && !this->UseFindModules &&
+           this->ConsideredConfigs.empty()))) {
       // The variable is not set.
       std::ostringstream e;
       std::ostringstream aw;
@@ -782,8 +813,9 @@ bool cmFindPackageCommand::HandlePackageMode()
               << ".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";
+              << this->Name
+              << "\", "
+                 "but CMake did not find one.\n";
           }
 
           if (this->Configs.size() == 1) {
@@ -804,8 +836,9 @@ bool cmFindPackageCommand::HandlePackageMode()
             << "\" 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.";
+            << 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 "
@@ -1076,7 +1109,7 @@ void cmFindPackageCommand::AppendSuccessInformation()
   this->RestoreFindDefinitions();
 
   // Pop the package stack
-  this->Makefile->FindPackageModuleStack.pop_back();
+  this->Makefile->FindPackageRootPathStack.pop_back();
 }
 
 void cmFindPackageCommand::ComputePrefixes()
@@ -1116,16 +1149,14 @@ void cmFindPackageCommand::FillPrefixesPackageRoot()
 {
   cmSearchPath& paths = this->LabeledPaths[PathLabel::PackageRoot];
 
-  // Add package specific search prefixes
-  // NOTE: This should be using const_reverse_iterator but HP aCC and
-  //       Oracle sunCC both currently have standard library issues
-  //       with the reverse iterator APIs.
-  for (std::deque<std::string>::reverse_iterator pkg =
-         this->Makefile->FindPackageModuleStack.rbegin();
-       pkg != this->Makefile->FindPackageModuleStack.rend(); ++pkg) {
-    std::string varName = *pkg + "_ROOT";
-    paths.AddCMakePath(varName);
-    paths.AddEnvPath(varName);
+  // Add the PACKAGE_ROOT_PATH from each enclosing find_package call.
+  for (std::deque<std::vector<std::string>>::const_reverse_iterator pkgPaths =
+         this->Makefile->FindPackageRootPathStack.rbegin();
+       pkgPaths != this->Makefile->FindPackageRootPathStack.rend();
+       ++pkgPaths) {
+    for (std::string const& path : *pkgPaths) {
+      paths.AddPath(path);
+    }
   }
 }
 
@@ -1208,14 +1239,14 @@ void cmFindPackageCommand::FillPrefixesSystemRegistry()
 }
 
 #if defined(_WIN32) && !defined(__CYGWIN__)
-#include <windows.h>
+#  include <windows.h>
 // 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
+#  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.
@@ -2039,7 +2070,7 @@ bool cmFindPackageCommand::SearchPrefix(std::string const& prefix_in)
   common.push_back("lib");
   common.push_back("share");
 
-  //  PREFIX/(lib/ARCH|lib|share)/cmake/(Foo|foo|FOO).*/
+  //  PREFIX/(lib/ARCH|lib*|share)/cmake/(Foo|foo|FOO).*/
   {
     cmFindPackageFileList lister(this);
     lister / cmFileListGeneratorFixed(prefix) /
@@ -2052,7 +2083,7 @@ bool cmFindPackageCommand::SearchPrefix(std::string const& prefix_in)
     }
   }
 
-  //  PREFIX/(lib/ARCH|lib|share)/(Foo|foo|FOO).*/
+  //  PREFIX/(lib/ARCH|lib*|share)/(Foo|foo|FOO).*/
   {
     cmFindPackageFileList lister(this);
     lister / cmFileListGeneratorFixed(prefix) /
@@ -2064,7 +2095,7 @@ bool cmFindPackageCommand::SearchPrefix(std::string const& prefix_in)
     }
   }
 
-  //  PREFIX/(lib/ARCH|lib|share)/(Foo|foo|FOO).*/(cmake|CMake)/
+  //  PREFIX/(lib/ARCH|lib*|share)/(Foo|foo|FOO).*/(cmake|CMake)/
   {
     cmFindPackageFileList lister(this);
     lister / cmFileListGeneratorFixed(prefix) /
@@ -2077,7 +2108,7 @@ bool cmFindPackageCommand::SearchPrefix(std::string const& prefix_in)
     }
   }
 
-  // PREFIX/(Foo|foo|FOO).*/(lib/ARCH|lib|share)/cmake/(Foo|foo|FOO).*/
+  // PREFIX/(Foo|foo|FOO).*/(lib/ARCH|lib*|share)/cmake/(Foo|foo|FOO).*/
   {
     cmFindPackageFileList lister(this);
     lister / cmFileListGeneratorFixed(prefix) /
@@ -2092,7 +2123,7 @@ bool cmFindPackageCommand::SearchPrefix(std::string const& prefix_in)
     }
   }
 
-  // PREFIX/(Foo|foo|FOO).*/(lib/ARCH|lib|share)/(Foo|foo|FOO).*/
+  // PREFIX/(Foo|foo|FOO).*/(lib/ARCH|lib*|share)/(Foo|foo|FOO).*/
   {
     cmFindPackageFileList lister(this);
     lister / cmFileListGeneratorFixed(prefix) /
@@ -2106,7 +2137,7 @@ bool cmFindPackageCommand::SearchPrefix(std::string const& prefix_in)
     }
   }
 
-  // PREFIX/(Foo|foo|FOO).*/(lib/ARCH|lib|share)/(Foo|foo|FOO).*/(cmake|CMake)/
+  // PREFIX/(Foo|foo|FOO).*/(lib/ARCH|lib*|share)/(Foo|foo|FOO).*/(cmake|CMake)/
   {
     cmFindPackageFileList lister(this);
     lister / cmFileListGeneratorFixed(prefix) /
diff --git a/Source/cmFindPackageCommand.h b/Source/cmFindPackageCommand.h
index 150a51d14..d8c7ab312 100644
--- a/Source/cmFindPackageCommand.h
+++ b/Source/cmFindPackageCommand.h
@@ -6,11 +6,25 @@
 #include "cmConfigure.h" // IWYU pragma: keep
 
 #include "cm_kwiml.h"
+#include <cstddef>
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
+// IWYU insists we should forward-declare instead of including <functional>,
+// but we cannot forward-declare reliably because some C++ standard libraries
+// put the template in an inline namespace.
+#ifdef CMAKE_IWYU
+/* clang-format off */
+namespace std {
+  template <class T> struct hash;
+}
+/* clang-format on */
+#else
+#  include <functional>
+#endif
+
 #include "cmFindCommon.h"
 
 class cmCommand;
@@ -194,6 +208,24 @@ private:
     }
   };
   std::vector<ConfigFileInfo> ConsideredConfigs;
+
+  friend struct std::hash<ConfigFileInfo>;
+};
+
+namespace std {
+
+template <>
+struct hash<cmFindPackageCommand::ConfigFileInfo>
+{
+  typedef cmFindPackageCommand::ConfigFileInfo argument_type;
+  typedef size_t result_type;
+
+  result_type operator()(argument_type const& s) const noexcept
+  {
+    result_type const h(std::hash<std::string>{}(s.filename));
+    return h;
+  }
 };
+}
 
 #endif
diff --git a/Source/cmFindProgramCommand.cxx b/Source/cmFindProgramCommand.cxx
index 1c6342841..13a18e20f 100644
--- a/Source/cmFindProgramCommand.cxx
+++ b/Source/cmFindProgramCommand.cxx
@@ -9,7 +9,7 @@
 class cmExecutionStatus;
 
 #if defined(__APPLE__)
-#include <CoreFoundation/CoreFoundation.h>
+#  include <CoreFoundation/CoreFoundation.h>
 #endif
 
 struct cmFindProgramHelper
diff --git a/Source/cmForEachCommand.cxx b/Source/cmForEachCommand.cxx
index df288bd68..9ff967c50 100644
--- a/Source/cmForEachCommand.cxx
+++ b/Source/cmForEachCommand.cxx
@@ -29,10 +29,10 @@ bool cmForEachFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff,
                                                  cmMakefile& mf,
                                                  cmExecutionStatus& inStatus)
 {
-  if (!cmSystemTools::Strucmp(lff.Name.c_str(), "foreach")) {
+  if (lff.Name.Lower == "foreach") {
     // record the number of nested foreach commands
     this->Depth++;
-  } else if (!cmSystemTools::Strucmp(lff.Name.c_str(), "endforeach")) {
+  } else if (lff.Name.Lower == "endforeach") {
     // if this is the endofreach for this statement
     if (!this->Depth) {
       // Remove the function blocker for this scope or bail.
@@ -97,7 +97,7 @@ bool cmForEachFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff,
 bool cmForEachFunctionBlocker::ShouldRemove(const cmListFileFunction& lff,
                                             cmMakefile& mf)
 {
-  if (!cmSystemTools::Strucmp(lff.Name.c_str(), "endforeach")) {
+  if (lff.Name.Lower == "endforeach") {
     std::vector<std::string> expandedArguments;
     mf.ExpandArguments(lff.Arguments, expandedArguments);
     // if the endforeach has arguments then make sure
diff --git a/Source/cmFortranParser.h b/Source/cmFortranParser.h
index 3f5ad8744..132b3e684 100644
--- a/Source/cmFortranParser.h
+++ b/Source/cmFortranParser.h
@@ -4,11 +4,11 @@
 #define cmFortranParser_h
 
 #if !defined(cmFortranLexer_cxx) && !defined(cmFortranParser_cxx)
-#include "cmConfigure.h" // IWYU pragma: keep
+#  include "cmConfigure.h" // IWYU pragma: keep
 
-#include <set>
-#include <string>
-#include <vector>
+#  include <set>
+#  include <string>
+#  include <vector>
 #endif
 
 #include <stddef.h> /* size_t */
@@ -39,11 +39,19 @@ 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_RuleUse(cmFortranParser* parser, const char* module_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_RuleModule(cmFortranParser* parser,
+                                const char* module_name);
+void cmFortranParser_RuleSubmodule(cmFortranParser* parser,
+                                   const char* module_name,
+                                   const char* submodule_name);
+void cmFortranParser_RuleSubmoduleNested(cmFortranParser* parser,
+                                         const char* module_name,
+                                         const char* submodule_name,
+                                         const char* nested_submodule_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);
@@ -65,20 +73,20 @@ struct cmFortran_yystype
 #define YYSTYPE cmFortran_yystype
 #define YYSTYPE_IS_DECLARED 1
 #if !defined(cmFortranLexer_cxx)
-#define YY_NO_UNISTD_H
-#include "cmFortranLexer.h"
+#  define YY_NO_UNISTD_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
-#endif
+#  if !defined(cmFortranParser_cxx)
+#    undef YY_EXTRA_TYPE
+#    undef YY_DECL
+#    undef YYSTYPE
+#    undef YYSTYPE_IS_DECLARED
+#  endif
 #endif
 
 #if !defined(cmFortranLexer_cxx) && !defined(cmFortranParser_cxx)
-#include <stack>
+#  include <stack>
 
 // Information about a single source file.
 class cmFortranSourceInfo
diff --git a/Source/cmFortranParserImpl.cxx b/Source/cmFortranParserImpl.cxx
index dd4f16bd9..01cbb7843 100644
--- a/Source/cmFortranParserImpl.cxx
+++ b/Source/cmFortranParserImpl.cxx
@@ -168,11 +168,16 @@ void cmFortranParser_Error(cmFortranParser* parser, const char* msg)
   parser->Error = msg ? msg : "unknown error";
 }
 
-void cmFortranParser_RuleUse(cmFortranParser* parser, const char* name)
+void cmFortranParser_RuleUse(cmFortranParser* parser, const char* module_name)
 {
-  if (!parser->InPPFalseBranch) {
-    parser->Info.Requires.insert(cmSystemTools::LowerCase(name));
+  if (parser->InPPFalseBranch) {
+    return;
   }
+
+  // syntax:   "use module_name"
+  // requires: "module_name.mod"
+  std::string const& mod_name = cmSystemTools::LowerCase(module_name);
+  parser->Info.Requires.insert(mod_name + ".mod");
 }
 
 void cmFortranParser_RuleLineDirective(cmFortranParser* parser,
@@ -225,11 +230,63 @@ void cmFortranParser_RuleInclude(cmFortranParser* parser, const char* name)
   }
 }
 
-void cmFortranParser_RuleModule(cmFortranParser* parser, const char* name)
+void cmFortranParser_RuleModule(cmFortranParser* parser,
+                                const char* module_name)
 {
-  if (!parser->InPPFalseBranch && !parser->InInterface) {
-    parser->Info.Provides.insert(cmSystemTools::LowerCase(name));
+  if (parser->InPPFalseBranch) {
+    return;
   }
+
+  if (!parser->InInterface) {
+    // syntax:   "module module_name"
+    // provides: "module_name.mod"
+    std::string const& mod_name = cmSystemTools::LowerCase(module_name);
+    parser->Info.Provides.insert(mod_name + ".mod");
+  }
+}
+
+void cmFortranParser_RuleSubmodule(cmFortranParser* parser,
+                                   const char* module_name,
+                                   const char* submodule_name)
+{
+  if (parser->InPPFalseBranch) {
+    return;
+  }
+
+  // syntax:   "submodule (module_name) submodule_name"
+  // requires: "module_name.mod"
+  // provides: "module_name@submodule_name.smod"
+  //
+  // FIXME: Some compilers split the submodule part of a module into a
+  // separate "module_name.smod" file.  Whether it is generated or
+  // not depends on conditions more subtle than we currently detect.
+  // For now we depend directly on "module_name.mod".
+
+  std::string const& mod_name = cmSystemTools::LowerCase(module_name);
+  std::string const& sub_name = cmSystemTools::LowerCase(submodule_name);
+  parser->Info.Requires.insert(mod_name + ".mod");
+  parser->Info.Provides.insert(mod_name + "@" + sub_name + ".smod");
+}
+
+void cmFortranParser_RuleSubmoduleNested(cmFortranParser* parser,
+                                         const char* module_name,
+                                         const char* submodule_name,
+                                         const char* nested_submodule_name)
+{
+  if (parser->InPPFalseBranch) {
+    return;
+  }
+
+  // syntax:   "submodule (module_name:submodule_name) nested_submodule_name"
+  // requires: "module_name@submodule_name.smod"
+  // provides: "module_name@nested_submodule_name.smod"
+
+  std::string const& mod_name = cmSystemTools::LowerCase(module_name);
+  std::string const& sub_name = cmSystemTools::LowerCase(submodule_name);
+  std::string const& nest_name =
+    cmSystemTools::LowerCase(nested_submodule_name);
+  parser->Info.Requires.insert(mod_name + "@" + sub_name + ".smod");
+  parser->Info.Provides.insert(mod_name + "@" + nest_name + ".smod");
 }
 
 void cmFortranParser_RuleDefine(cmFortranParser* parser, const char* macro)
diff --git a/Source/cmFunctionCommand.cxx b/Source/cmFunctionCommand.cxx
index 774df849c..67c9e9a5d 100644
--- a/Source/cmFunctionCommand.cxx
+++ b/Source/cmFunctionCommand.cxx
@@ -9,7 +9,6 @@
 #include "cmMakefile.h"
 #include "cmPolicies.h"
 #include "cmState.h"
-#include "cmSystemTools.h"
 
 // define the class for function commands
 class cmFunctionHelperCommand : public cmCommand
@@ -128,9 +127,9 @@ bool cmFunctionFunctionBlocker::IsFunctionBlocked(
 {
   // 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 (lff.Name.Lower == "function") {
     this->Depth++;
-  } else if (!cmSystemTools::Strucmp(lff.Name.c_str(), "endfunction")) {
+  } else if (lff.Name.Lower == "endfunction") {
     // if this is the endfunction for this function then execute
     if (!this->Depth) {
       // create a new command and add it to cmake
@@ -157,7 +156,7 @@ bool cmFunctionFunctionBlocker::IsFunctionBlocked(
 bool cmFunctionFunctionBlocker::ShouldRemove(const cmListFileFunction& lff,
                                              cmMakefile& mf)
 {
-  if (!cmSystemTools::Strucmp(lff.Name.c_str(), "endfunction")) {
+  if (lff.Name.Lower == "endfunction") {
     std::vector<std::string> expandedArguments;
     mf.ExpandArguments(lff.Arguments, expandedArguments,
                        this->GetStartingContext().FilePath.c_str());
diff --git a/Source/cmGeneratedFileStream.cxx b/Source/cmGeneratedFileStream.cxx
index c0a74a5f4..6bdf3a45c 100644
--- a/Source/cmGeneratedFileStream.cxx
+++ b/Source/cmGeneratedFileStream.cxx
@@ -7,8 +7,8 @@
 #include "cmSystemTools.h"
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
-#include "cm_codecvt.hxx"
-#include "cm_zlib.h"
+#  include "cm_codecvt.hxx"
+#  include "cm_zlib.h"
 #endif
 
 cmGeneratedFileStream::cmGeneratedFileStream(Encoding encoding)
diff --git a/Source/cmGeneratedFileStream.h b/Source/cmGeneratedFileStream.h
index a96f38fa8..48f93c52b 100644
--- a/Source/cmGeneratedFileStream.h
+++ b/Source/cmGeneratedFileStream.h
@@ -67,8 +67,9 @@ 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;
@@ -108,7 +109,7 @@ public:
   /**
    * Close the output file.  This should be used only with an open
    * stream.  The temporary file is atomically renamed to the
-   * destionation file if the stream is still valid when this method
+   * destination file if the stream is still valid when this method
    * is called.
    */
   bool Close();
diff --git a/Source/cmGeneratorExpressionDAGChecker.cxx b/Source/cmGeneratorExpressionDAGChecker.cxx
index f0eafb46a..face28228 100644
--- a/Source/cmGeneratorExpressionDAGChecker.cxx
+++ b/Source/cmGeneratorExpressionDAGChecker.cxx
@@ -154,6 +154,18 @@ bool cmGeneratorExpressionDAGChecker::GetTransitivePropertiesOnly()
   return top->TransitivePropertiesOnly;
 }
 
+bool cmGeneratorExpressionDAGChecker::EvaluatingGenexExpression()
+{
+  const cmGeneratorExpressionDAGChecker* top = this;
+  const cmGeneratorExpressionDAGChecker* parent = this->Parent;
+  while (parent) {
+    top = parent;
+    parent = parent->Parent;
+  }
+
+  return top->Property == "TARGET_GENEX_EVAL" || top->Property == "GENEX_EVAL";
+}
+
 bool cmGeneratorExpressionDAGChecker::EvaluatingLinkLibraries(const char* tgt)
 {
   const cmGeneratorExpressionDAGChecker* top = this;
diff --git a/Source/cmGeneratorExpressionDAGChecker.h b/Source/cmGeneratorExpressionDAGChecker.h
index 3f73fca8a..a3a8f69c3 100644
--- a/Source/cmGeneratorExpressionDAGChecker.h
+++ b/Source/cmGeneratorExpressionDAGChecker.h
@@ -61,6 +61,7 @@ struct cmGeneratorExpressionDAGChecker
   void ReportError(cmGeneratorExpressionContext* context,
                    const std::string& expr);
 
+  bool EvaluatingGenexExpression();
   bool EvaluatingLinkLibraries(const char* tgt = nullptr);
 
 #define DECLARE_TRANSITIVE_PROPERTY_METHOD(METHOD) bool METHOD() const;
diff --git a/Source/cmGeneratorExpressionEvaluator.cxx b/Source/cmGeneratorExpressionEvaluator.cxx
index dbc6840fc..f9a6d6454 100644
--- a/Source/cmGeneratorExpressionEvaluator.cxx
+++ b/Source/cmGeneratorExpressionEvaluator.cxx
@@ -41,8 +41,9 @@ std::string GeneratorExpressionContent::ProcessArbitraryContent(
     for (; it != end; ++it) {
       if (node->RequiresLiteralInput()) {
         if ((*it)->GetType() != cmGeneratorExpressionEvaluator::Text) {
-          reportError(context, this->GetOriginalExpression(), "$<" +
-                        identifier + "> expression requires literal input.");
+          reportError(context, this->GetOriginalExpression(),
+                      "$<" + identifier +
+                        "> expression requires literal input.");
           return std::string();
         }
       }
@@ -157,7 +158,8 @@ std::string GeneratorExpressionContent::EvaluateParameters(
       reportError(context, this->GetOriginalExpression(),
                   "$<" + identifier + "> expression requires no parameters.");
     } else if (numExpected == 1) {
-      reportError(context, this->GetOriginalExpression(), "$<" + identifier +
+      reportError(context, this->GetOriginalExpression(),
+                  "$<" + identifier +
                     "> expression requires "
                     "exactly one parameter.");
     } else {
@@ -172,12 +174,14 @@ std::string GeneratorExpressionContent::EvaluateParameters(
 
   if (numExpected == cmGeneratorExpressionNode::OneOrMoreParameters &&
       parameters.empty()) {
-    reportError(context, this->GetOriginalExpression(), "$<" + identifier +
+    reportError(context, this->GetOriginalExpression(),
+                "$<" + identifier +
                   "> expression requires at least one parameter.");
   }
   if (numExpected == cmGeneratorExpressionNode::OneOrZeroParameters &&
       parameters.size() > 1) {
-    reportError(context, this->GetOriginalExpression(), "$<" + identifier +
+    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 92dac79ea..056179950 100644
--- a/Source/cmGeneratorExpressionEvaluator.h
+++ b/Source/cmGeneratorExpressionEvaluator.h
@@ -7,6 +7,7 @@
 
 #include <stddef.h>
 #include <string>
+#include <utility>
 #include <vector>
 
 struct cmGeneratorExpressionContext;
@@ -64,17 +65,16 @@ private:
 struct GeneratorExpressionContent : public cmGeneratorExpressionEvaluator
 {
   GeneratorExpressionContent(const char* startContent, size_t length);
-  void SetIdentifier(
-    std::vector<cmGeneratorExpressionEvaluator*> const& identifier)
+
+  void SetIdentifier(std::vector<cmGeneratorExpressionEvaluator*> identifier)
   {
-    this->IdentifierChildren = identifier;
+    this->IdentifierChildren = std::move(identifier);
   }
 
   void SetParameters(
-    std::vector<std::vector<cmGeneratorExpressionEvaluator*>> const&
-      parameters)
+    std::vector<std::vector<cmGeneratorExpressionEvaluator*>> parameters)
   {
-    this->ParamChildren = parameters;
+    this->ParamChildren = std::move(parameters);
   }
 
   Type GetType() const override
diff --git a/Source/cmGeneratorExpressionNode.cxx b/Source/cmGeneratorExpressionNode.cxx
index c1f1ee489..1594904e7 100644
--- a/Source/cmGeneratorExpressionNode.cxx
+++ b/Source/cmGeneratorExpressionNode.cxx
@@ -275,6 +275,203 @@ static const struct EqualNode : public cmGeneratorExpressionNode
   }
 } equalNode;
 
+static const struct InListNode : public cmGeneratorExpressionNode
+{
+  InListNode() {}
+
+  int NumExpectedParameters() const override { return 2; }
+
+  std::string Evaluate(
+    const std::vector<std::string>& parameters,
+    cmGeneratorExpressionContext* /*context*/,
+    const GeneratorExpressionContent* /*content*/,
+    cmGeneratorExpressionDAGChecker* /*dagChecker*/) const override
+  {
+    std::vector<std::string> values;
+    cmSystemTools::ExpandListArgument(parameters[1], values);
+    if (values.empty()) {
+      return "0";
+    }
+
+    return std::find(values.cbegin(), values.cend(), parameters.front()) ==
+        values.cend()
+      ? "0"
+      : "1";
+  }
+} inListNode;
+
+static const struct TargetExistsNode : public cmGeneratorExpressionNode
+{
+  TargetExistsNode() {}
+
+  int NumExpectedParameters() const override { return 1; }
+
+  std::string Evaluate(
+    const std::vector<std::string>& parameters,
+    cmGeneratorExpressionContext* context,
+    const GeneratorExpressionContent* content,
+    cmGeneratorExpressionDAGChecker* /*dagChecker*/) const override
+  {
+    if (parameters.size() != 1) {
+      reportError(context, content->GetOriginalExpression(),
+                  "$<TARGET_EXISTS:...> expression requires one parameter");
+      return std::string();
+    }
+
+    std::string targetName = parameters.front();
+    if (targetName.empty() ||
+        !cmGeneratorExpression::IsValidTargetName(targetName)) {
+      reportError(context, content->GetOriginalExpression(),
+                  "$<TARGET_EXISTS:tgt> expression requires a non-empty "
+                  "valid target name.");
+      return std::string();
+    }
+
+    return context->LG->GetMakefile()->FindTargetToUse(targetName) ? "1" : "0";
+  }
+} targetExistsNode;
+
+static const struct TargetNameIfExistsNode : public cmGeneratorExpressionNode
+{
+  TargetNameIfExistsNode() {}
+
+  int NumExpectedParameters() const override { return 1; }
+
+  std::string Evaluate(
+    const std::vector<std::string>& parameters,
+    cmGeneratorExpressionContext* context,
+    const GeneratorExpressionContent* content,
+    cmGeneratorExpressionDAGChecker* /*dagChecker*/) const override
+  {
+    if (parameters.size() != 1) {
+      reportError(context, content->GetOriginalExpression(),
+                  "$<TARGET_NAME_IF_EXISTS:...> expression requires one "
+                  "parameter");
+      return std::string();
+    }
+
+    std::string targetName = parameters.front();
+    if (targetName.empty() ||
+        !cmGeneratorExpression::IsValidTargetName(targetName)) {
+      reportError(context, content->GetOriginalExpression(),
+                  "$<TARGET_NAME_IF_EXISTS:tgt> expression requires a "
+                  "non-empty valid target name.");
+      return std::string();
+    }
+
+    return context->LG->GetMakefile()->FindTargetToUse(targetName)
+      ? targetName
+      : std::string();
+  }
+} targetNameIfExistsNode;
+
+struct GenexEvaluator : public cmGeneratorExpressionNode
+{
+  GenexEvaluator() {}
+
+protected:
+  std::string EvaluateExpression(
+    const std::string& genexOperator, const std::string& expression,
+    cmGeneratorExpressionContext* context,
+    const GeneratorExpressionContent* content,
+    cmGeneratorExpressionDAGChecker* dagCheckerParent) const
+  {
+    if (context->HeadTarget) {
+      cmGeneratorExpressionDAGChecker dagChecker(
+        context->Backtrace, context->HeadTarget->GetName(), genexOperator,
+        content, dagCheckerParent);
+      switch (dagChecker.Check()) {
+        case cmGeneratorExpressionDAGChecker::SELF_REFERENCE:
+        case cmGeneratorExpressionDAGChecker::CYCLIC_REFERENCE: {
+          dagChecker.ReportError(context, content->GetOriginalExpression());
+          return std::string();
+        }
+        case cmGeneratorExpressionDAGChecker::ALREADY_SEEN:
+        case cmGeneratorExpressionDAGChecker::DAG:
+          break;
+      }
+
+      return this->EvaluateDependentExpression(
+        expression, context->LG, context, context->HeadTarget,
+        context->CurrentTarget, &dagChecker);
+    }
+
+    return this->EvaluateDependentExpression(
+      expression, context->LG, context, context->HeadTarget,
+      context->CurrentTarget, dagCheckerParent);
+  }
+};
+
+static const struct TargetGenexEvalNode : public GenexEvaluator
+{
+  TargetGenexEvalNode() {}
+
+  int NumExpectedParameters() const override { return 2; }
+
+  bool AcceptsArbitraryContentParameter() const override { return true; }
+
+  std::string Evaluate(
+    const std::vector<std::string>& parameters,
+    cmGeneratorExpressionContext* context,
+    const GeneratorExpressionContent* content,
+    cmGeneratorExpressionDAGChecker* dagCheckerParent) const override
+  {
+    const std::string& targetName = parameters.front();
+    if (targetName.empty() ||
+        !cmGeneratorExpression::IsValidTargetName(targetName)) {
+      reportError(context, content->GetOriginalExpression(),
+                  "$<TARGET_GENEX_EVAL:tgt, ...> expression requires a "
+                  "non-empty valid target name.");
+      return std::string();
+    }
+
+    const auto* target = context->LG->FindGeneratorTargetToUse(targetName);
+    if (!target) {
+      std::ostringstream e;
+      e << "$<TARGET_GENEX_EVAL:tgt, ...> target \"" << targetName
+        << "\" not found.";
+      reportError(context, content->GetOriginalExpression(), e.str());
+      return std::string();
+    }
+
+    const std::string& expression = parameters[1];
+    if (expression.empty()) {
+      return expression;
+    }
+
+    cmGeneratorExpressionContext targetContext(
+      context->LG, context->Config, context->Quiet, target, target,
+      context->EvaluateForBuildsystem, context->Backtrace, context->Language);
+
+    return this->EvaluateExpression("TARGET_GENEX_EVAL", expression,
+                                    &targetContext, content, dagCheckerParent);
+  }
+} targetGenexEvalNode;
+
+static const struct GenexEvalNode : public GenexEvaluator
+{
+  GenexEvalNode() {}
+
+  int NumExpectedParameters() const override { return 1; }
+
+  bool AcceptsArbitraryContentParameter() const override { return true; }
+
+  std::string Evaluate(
+    const std::vector<std::string>& parameters,
+    cmGeneratorExpressionContext* context,
+    const GeneratorExpressionContent* content,
+    cmGeneratorExpressionDAGChecker* dagCheckerParent) const override
+  {
+    const std::string& expression = parameters[0];
+    if (expression.empty()) {
+      return expression;
+    }
+
+    return this->EvaluateExpression("GENEX_EVAL", expression, context, content,
+                                    dagCheckerParent);
+  }
+} genexEvalNode;
+
 static const struct LowerCaseNode : public cmGeneratorExpressionNode
 {
   LowerCaseNode() {}
@@ -816,16 +1013,7 @@ static const struct CompileLanguageNode : public cmGeneratorExpressionNode
       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()) {
-      reportError(context, content->GetOriginalExpression(),
-                  "$<COMPILE_LANGUAGE:...> Unknown language.");
-      return std::string();
-    }
     std::string genName = gg->GetName();
     if (genName.find("Makefiles") == std::string::npos &&
         genName.find("Ninja") == std::string::npos &&
@@ -1034,7 +1222,9 @@ static const struct TargetPropertyNode : public cmGeneratorExpressionNode
     const char* prop = target->GetProperty(propertyName);
 
     if (dagCheckerParent) {
-      if (dagCheckerParent->EvaluatingLinkLibraries()) {
+      if (dagCheckerParent->EvaluatingGenexExpression()) {
+        // No check required.
+      } else if (dagCheckerParent->EvaluatingLinkLibraries()) {
 #define TRANSITIVE_PROPERTY_COMPARE(PROPERTY)                                 \
   (#PROPERTY == propertyName || "INTERFACE_" #PROPERTY == propertyName) ||
         if (CM_FOR_EACH_TRANSITIVE_PROPERTY_NAME(
@@ -1231,8 +1421,9 @@ static const struct TargetObjectsNode : public cmGeneratorExpressionNode
         std::ostringstream e;
         e << "The evaluation of the TARGET_OBJECTS generator expression "
              "is only suitable for consumption by CMake (limited"
-          << reason << ").  "
-                       "It is not suitable for writing out elsewhere.";
+          << reason
+          << ").  "
+             "It is not suitable for writing out elsewhere.";
         reportError(context, content->GetOriginalExpression(), e.str());
         return std::string();
       }
@@ -1459,7 +1650,7 @@ static const struct TargetPolicyNode : public cmGeneratorExpressionNode
       CM_FOR_EACH_TARGET_POLICY(TARGET_POLICY_LIST_ITEM)
 
 #undef TARGET_POLICY_LIST_ITEM
-        );
+    );
     return std::string();
   }
 
@@ -1585,7 +1776,8 @@ struct TargetFilesystemArtifactResultCreator<ArtifactLinkerTag>
                     "executables with ENABLE_EXPORTS.");
       return std::string();
     }
-    cmStateEnums::ArtifactType artifact = target->HasImportLibrary()
+    cmStateEnums::ArtifactType artifact =
+      target->HasImportLibrary(context->Config)
       ? cmStateEnums::ImportLibraryArtifact
       : cmStateEnums::RuntimeBinaryArtifact;
     return target->GetFullPath(context->Config, artifact);
@@ -1713,13 +1905,15 @@ struct TargetFilesystemArtifact : public cmGeneratorExpressionNode
     }
     if (target->GetType() >= cmStateEnums::OBJECT_LIBRARY &&
         target->GetType() != cmStateEnums::UNKNOWN_LIBRARY) {
-      ::reportError(context, content->GetOriginalExpression(), "Target \"" +
-                      name + "\" is not an executable or 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");
@@ -1827,6 +2021,7 @@ const cmGeneratorExpressionNode* cmGeneratorExpressionNode::GetNode(
     nodeMap["TARGET_BUNDLE_CONTENT_DIR"] = &targetBundleContentDirNode;
     nodeMap["STREQUAL"] = &strEqualNode;
     nodeMap["EQUAL"] = &equalNode;
+    nodeMap["IN_LIST"] = &inListNode;
     nodeMap["LOWER_CASE"] = &lowerCaseNode;
     nodeMap["UPPER_CASE"] = &upperCaseNode;
     nodeMap["MAKE_C_IDENTIFIER"] = &makeCIdentifierNode;
@@ -1839,6 +2034,10 @@ const cmGeneratorExpressionNode* cmGeneratorExpressionNode::GetNode(
     nodeMap["TARGET_NAME"] = &targetNameNode;
     nodeMap["TARGET_OBJECTS"] = &targetObjectsNode;
     nodeMap["TARGET_POLICY"] = &targetPolicyNode;
+    nodeMap["TARGET_EXISTS"] = &targetExistsNode;
+    nodeMap["TARGET_NAME_IF_EXISTS"] = &targetNameIfExistsNode;
+    nodeMap["TARGET_GENEX_EVAL"] = &targetGenexEvalNode;
+    nodeMap["GENEX_EVAL"] = &genexEvalNode;
     nodeMap["BUILD_INTERFACE"] = &buildInterfaceNode;
     nodeMap["INSTALL_INTERFACE"] = &installInterfaceNode;
     nodeMap["INSTALL_PREFIX"] = &installPrefixNode;
diff --git a/Source/cmGeneratorExpressionParser.cxx b/Source/cmGeneratorExpressionParser.cxx
index 278de0444..489970ce3 100644
--- a/Source/cmGeneratorExpressionParser.cxx
+++ b/Source/cmGeneratorExpressionParser.cxx
@@ -6,6 +6,7 @@
 
 #include <assert.h>
 #include <stddef.h>
+#include <utility>
 
 cmGeneratorExpressionParser::cmGeneratorExpressionParser(
   const std::vector<cmGeneratorExpressionToken>& tokens)
@@ -86,13 +87,13 @@ void cmGeneratorExpressionParser::ParseGeneratorExpression(
 
   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);
+    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);
+    content->SetIdentifier(std::move(identifier));
     result.push_back(content);
     return;
   }
@@ -198,8 +199,8 @@ void cmGeneratorExpressionParser::ParseGeneratorExpression(
     ((this->it - 1)->Content - startToken->Content) + (this->it - 1)->Length;
   GeneratorExpressionContent* content =
     new GeneratorExpressionContent(startToken->Content, contentLength);
-  content->SetIdentifier(identifier);
-  content->SetParameters(parameters);
+  content->SetIdentifier(std::move(identifier));
+  content->SetParameters(std::move(parameters));
   result.push_back(content);
 }
 
diff --git a/Source/cmGeneratorTarget.cxx b/Source/cmGeneratorTarget.cxx
index 2bb01b29e..b223c5eed 100644
--- a/Source/cmGeneratorTarget.cxx
+++ b/Source/cmGeneratorTarget.cxx
@@ -46,8 +46,9 @@ const char* cmTargetPropertyComputer::GetSources<cmGeneratorTarget>(
 }
 
 template <>
-const char* cmTargetPropertyComputer::ComputeLocationForBuild<
-  cmGeneratorTarget>(cmGeneratorTarget const* tgt)
+const char*
+cmTargetPropertyComputer::ComputeLocationForBuild<cmGeneratorTarget>(
+  cmGeneratorTarget const* tgt)
 {
   return tgt->GetLocation("");
 }
@@ -132,8 +133,8 @@ cmGeneratorTarget::cmGeneratorTarget(cmTarget* t, cmLocalGenerator* lg)
                                      this->SourceEntries, true);
 
   this->DLLPlatform =
-    (this->Makefile->IsOn("WIN32") || this->Makefile->IsOn("CYGWIN") ||
-     this->Makefile->IsOn("MINGW"));
+    strcmp(this->Makefile->GetSafeDefinition("CMAKE_IMPORT_LIBRARY_SUFFIX"),
+           "") != 0;
 
   this->PolicyMap = t->PolicyMap;
 }
@@ -240,13 +241,16 @@ const char* cmGeneratorTarget::GetOutputTargetType(
     case cmStateEnums::MODULE_LIBRARY:
       switch (artifact) {
         case cmStateEnums::RuntimeBinaryArtifact:
-          // Module import libraries are treated as archive targets.
+          // Module libraries are always treated as library targets.
           return "LIBRARY";
         case cmStateEnums::ImportLibraryArtifact:
-          // Module libraries are always treated as library targets.
+          // Module import libraries are treated as archive targets.
           return "ARCHIVE";
       }
       break;
+    case cmStateEnums::OBJECT_LIBRARY:
+      // Object libraries are always treated as object targets.
+      return "OBJECT";
     case cmStateEnums::EXECUTABLE:
       switch (artifact) {
         case cmStateEnums::RuntimeBinaryArtifact:
@@ -808,6 +812,26 @@ static void AddInterfaceEntries(
   }
 }
 
+static void AddObjectEntries(
+  cmGeneratorTarget const* thisTarget, std::string const& config,
+  std::vector<cmGeneratorTarget::TargetPropertyEntry*>& entries)
+{
+  if (cmLinkImplementationLibraries const* impl =
+        thisTarget->GetLinkImplementationLibraries(config)) {
+    for (cmLinkImplItem const& lib : impl->Libraries) {
+      if (lib.Target &&
+          lib.Target->GetType() == cmStateEnums::OBJECT_LIBRARY) {
+        std::string genex = "$<TARGET_OBJECTS:" + lib + ">";
+        cmGeneratorExpression ge(lib.Backtrace);
+        std::unique_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(genex);
+        cge->SetEvaluateForBuildsystem(true);
+        entries.push_back(
+          new cmGeneratorTarget::TargetPropertyEntry(std::move(cge), lib));
+      }
+    }
+  }
+}
+
 static bool processSources(
   cmGeneratorTarget const* tgt,
   const std::vector<cmGeneratorTarget::TargetPropertyEntry*>& entries,
@@ -848,13 +872,10 @@ static bool processSources(
         std::ostringstream err;
         if (!targetName.empty()) {
           err << "Target \"" << targetName
-              << "\" contains relative "
-                 "path in its INTERFACE_SOURCES:\n"
-                 "  \""
+              << "\" contains relative path in its INTERFACE_SOURCES:\n  \""
               << src << "\"";
         } else {
-          err << "Found relative path while evaluating sources of "
-                 "\""
+          err << "Found relative path while evaluating sources of \""
               << tgt->GetName() << "\":\n  \"" << src << "\"\n";
         }
         tgt->GetLocalGenerator()->IssueMessage(cmake::FATAL_ERROR, err.str());
@@ -873,8 +894,9 @@ static bool processSources(
     }
     if (!usedSources.empty()) {
       tgt->GetLocalGenerator()->GetCMakeInstance()->IssueMessage(
-        cmake::LOG, std::string("Used sources for target ") + tgt->GetName() +
-          ":\n" + usedSources,
+        cmake::LOG,
+        std::string("Used sources for target ") + tgt->GetName() + ":\n" +
+          usedSources,
         entry->ge->GetBacktrace());
     }
   }
@@ -931,23 +953,32 @@ void cmGeneratorTarget::GetSourceFiles(std::vector<std::string>& files,
     processSources(this, this->SourceEntries, files, uniqueSrcs, &dagChecker,
                    config, debugSources);
 
+  // Collect INTERFACE_SOURCES of all direct link-dependencies.
   std::vector<cmGeneratorTarget::TargetPropertyEntry*>
     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);
 
+  // Collect TARGET_OBJECTS of direct object link-dependencies.
+  std::vector<cmGeneratorTarget::TargetPropertyEntry*> linkObjectsEntries;
+  AddObjectEntries(this, config, linkObjectsEntries);
+  std::vector<std::string>::size_type numFilesBefore2 = files.size();
+  bool contextDependentObjects =
+    processSources(this, linkObjectsEntries, files, uniqueSrcs, &dagChecker,
+                   config, debugSources);
+
   if (!contextDependentDirectSources &&
-      !(contextDependentInterfaceSources && numFilesBefore < files.size())) {
+      !(contextDependentInterfaceSources && numFilesBefore < files.size()) &&
+      !(contextDependentObjects && numFilesBefore2 < files.size())) {
     this->LinkImplementationLanguageIsContextDependent = false;
   }
 
   cmDeleteAll(linkInterfaceSourcesEntries);
+  cmDeleteAll(linkObjectsEntries);
 }
 
 void cmGeneratorTarget::GetSourceFiles(std::vector<cmSourceFile*>& files,
@@ -1053,9 +1084,6 @@ void cmGeneratorTarget::ComputeKindedSources(KindedSources& files,
       kind = SourceKindHeader;
     } else if (sf->GetPropertyAsBool("EXTERNAL_OBJECT")) {
       kind = SourceKindExternalObject;
-      if (this->GetType() == cmStateEnums::OBJECT_LIBRARY) {
-        badObjLib.push_back(sf);
-      }
     } else if (!sf->GetLanguage().empty()) {
       kind = SourceKindObjectSource;
     } else if (ext == "def") {
@@ -1673,6 +1701,7 @@ bool cmGeneratorTarget::HaveWellDefinedOutputFiles() const
   return this->GetType() == cmStateEnums::STATIC_LIBRARY ||
     this->GetType() == cmStateEnums::SHARED_LIBRARY ||
     this->GetType() == cmStateEnums::MODULE_LIBRARY ||
+    this->GetType() == cmStateEnums::OBJECT_LIBRARY ||
     this->GetType() == cmStateEnums::EXECUTABLE;
 }
 
@@ -2001,8 +2030,13 @@ void cmGeneratorTarget::ComputeModuleDefinitionInfo(
   info.WindowsExportAllSymbols =
     this->Makefile->IsOn("CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS") &&
     this->GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS");
+#if defined(_WIN32) && defined(CMAKE_BUILD_WITH_CMAKE)
   info.DefFileGenerated =
     info.WindowsExportAllSymbols || info.Sources.size() > 1;
+#else
+  // Our __create_def helper is only available on Windows.
+  info.DefFileGenerated = false;
+#endif
   if (info.DefFileGenerated) {
     info.DefFile = this->ObjectDirectory /* has slash */ + "exports.def";
   } else if (!info.Sources.empty()) {
@@ -2521,8 +2555,9 @@ static void processIncludeDirectories(
     }
     if (!usedIncludes.empty()) {
       tgt->GetLocalGenerator()->GetCMakeInstance()->IssueMessage(
-        cmake::LOG, std::string("Used includes for target ") + tgt->GetName() +
-          ":\n" + usedIncludes,
+        cmake::LOG,
+        std::string("Used includes for target ") + tgt->GetName() + ":\n" +
+          usedIncludes,
         entry->ge->GetBacktrace());
     }
   }
@@ -2592,13 +2627,20 @@ std::vector<std::string> cmGeneratorTarget::GetIncludeDirectories(
   return includes;
 }
 
+enum class OptionsParse
+{
+  None,
+  Shell
+};
+
 static void processCompileOptionsInternal(
   cmGeneratorTarget const* tgt,
   const std::vector<cmGeneratorTarget::TargetPropertyEntry*>& entries,
   std::vector<std::string>& options,
   std::unordered_set<std::string>& uniqueOptions,
   cmGeneratorExpressionDAGChecker* dagChecker, const std::string& config,
-  bool debugOptions, const char* logName, std::string const& language)
+  bool debugOptions, const char* logName, std::string const& language,
+  OptionsParse parse)
 {
   for (cmGeneratorTarget::TargetPropertyEntry* entry : entries) {
     std::vector<std::string> entryOptions;
@@ -2609,7 +2651,12 @@ static void processCompileOptionsInternal(
     std::string usedOptions;
     for (std::string const& opt : entryOptions) {
       if (uniqueOptions.insert(opt).second) {
-        options.push_back(opt);
+        if (parse == OptionsParse::Shell &&
+            cmHasLiteralPrefix(opt, "SHELL:")) {
+          cmSystemTools::ParseUnixCommandLine(opt.c_str() + 6, options);
+        } else {
+          options.push_back(opt);
+        }
         if (debugOptions) {
           usedOptions += " * " + opt + "\n";
         }
@@ -2617,8 +2664,9 @@ static void processCompileOptionsInternal(
     }
     if (!usedOptions.empty()) {
       tgt->GetLocalGenerator()->GetCMakeInstance()->IssueMessage(
-        cmake::LOG, std::string("Used compile ") + logName +
-          std::string(" for target ") + tgt->GetName() + ":\n" + usedOptions,
+        cmake::LOG,
+        std::string("Used compile ") + logName + std::string(" for target ") +
+          tgt->GetName() + ":\n" + usedOptions,
         entry->ge->GetBacktrace());
     }
   }
@@ -2634,7 +2682,7 @@ static void processCompileOptions(
 {
   processCompileOptionsInternal(tgt, entries, options, uniqueOptions,
                                 dagChecker, config, debugOptions, "options",
-                                language);
+                                language, OptionsParse::Shell);
 }
 
 void cmGeneratorTarget::GetCompileOptions(std::vector<std::string>& result,
@@ -2688,7 +2736,7 @@ static void processCompileFeatures(
 {
   processCompileOptionsInternal(tgt, entries, options, uniqueOptions,
                                 dagChecker, config, debugOptions, "features",
-                                std::string());
+                                std::string(), OptionsParse::None);
 }
 
 void cmGeneratorTarget::GetCompileFeatures(std::vector<std::string>& result,
@@ -2738,7 +2786,7 @@ static void processCompileDefinitions(
 {
   processCompileOptionsInternal(tgt, entries, options, uniqueOptions,
                                 dagChecker, config, debugOptions,
-                                "definitions", language);
+                                "definitions", language, OptionsParse::None);
 }
 
 void cmGeneratorTarget::GetCompileDefinitions(
@@ -3914,8 +3962,9 @@ PropertyType checkInterfacePropertyCompatibility(cmGeneratorTarget const* tgt,
           e << "Property " << p << " on target \"" << tgt->GetName()
             << "\" does\nnot match the "
                "INTERFACE_"
-            << p << " property requirement\nof "
-                    "dependency \""
+            << p
+            << " property requirement\nof "
+               "dependency \""
             << theTarget->GetName() << "\".\n";
           cmSystemTools::Error(e.str().c_str());
           break;
@@ -4568,13 +4617,24 @@ bool cmGeneratorTarget::ComputePDBOutputDir(const std::string& kind,
   // Select an output directory.
   if (const char* config_outdir = this->GetProperty(configProp)) {
     // Use the user-specified per-configuration output directory.
-    out = config_outdir;
+    cmGeneratorExpression ge;
+    std::unique_ptr<cmCompiledGeneratorExpression> cge =
+      ge.Parse(config_outdir);
+    out = cge->Evaluate(this->LocalGenerator, config);
 
     // Skip per-configuration subdirectory.
     conf.clear();
   } else if (const char* outdir = this->GetProperty(propertyName)) {
     // Use the user-specified output directory.
-    out = outdir;
+    cmGeneratorExpression ge;
+    std::unique_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) {
+      conf.clear();
+    }
   }
   if (out.empty()) {
     return false;
@@ -4934,6 +4994,16 @@ void cmGeneratorTarget::ComputeImportInfo(std::string const& desired_config,
     }
   }
 
+  // Get information if target is managed assembly.
+  {
+    std::string linkProp = "IMPORTED_COMMON_LANGUAGE_RUNTIME";
+    if (auto pc = this->GetProperty(linkProp + suffix)) {
+      info.Managed = this->CheckManagedType(pc);
+    } else if (auto p = this->GetProperty(linkProp)) {
+      info.Managed = this->CheckManagedType(p);
+    }
+  }
+
   // Get the cyclic repetition count.
   if (this->GetType() == cmStateEnums::STATIC_LIBRARY) {
     std::string linkProp = "IMPORTED_LINK_INTERFACE_MULTIPLICITY";
@@ -5151,6 +5221,18 @@ void cmGeneratorTarget::GetLanguages(std::set<std::string>& languages,
   }
 }
 
+bool cmGeneratorTarget::HasLanguage(std::string const& language,
+                                    std::string const& config,
+                                    bool exclusive) const
+{
+  std::set<std::string> languages;
+  this->GetLanguages(languages, config);
+  // add linker language (if it is different from compiler languages)
+  languages.insert(this->GetLinkerLanguage(config));
+  return (languages.size() == 1 || !exclusive) &&
+    languages.count(language) > 0;
+}
+
 void cmGeneratorTarget::ComputeLinkImplementationLanguages(
   const std::string& config, cmOptionalLinkImplementation& impl) const
 {
@@ -5325,20 +5407,6 @@ cmGeneratorTarget* cmGeneratorTarget::FindTargetToLink(
     tgt = nullptr;
   }
 
-  if (tgt && tgt->GetType() == cmStateEnums::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.";
-    cmake* cm = this->LocalGenerator->GetCMakeInstance();
-    cm->IssueMessage(cmake::FATAL_ERROR, e.str(), this->GetBacktrace());
-    tgt = nullptr;
-  }
-
   return tgt;
 }
 
@@ -5351,16 +5419,17 @@ std::string cmGeneratorTarget::GetPDBDirectory(const std::string& config) const
   return "";
 }
 
-bool cmGeneratorTarget::HasImplibGNUtoMS() const
+bool cmGeneratorTarget::HasImplibGNUtoMS(std::string const& config) const
 {
-  return this->HasImportLibrary() && this->GetPropertyAsBool("GNUtoMS");
+  return this->HasImportLibrary(config) && this->GetPropertyAsBool("GNUtoMS");
 }
 
-bool cmGeneratorTarget::GetImplibGNUtoMS(std::string const& gnuName,
+bool cmGeneratorTarget::GetImplibGNUtoMS(std::string const& config,
+                                         std::string const& gnuName,
                                          std::string& out,
                                          const char* newExt) const
 {
-  if (this->HasImplibGNUtoMS() && gnuName.size() > 6 &&
+  if (this->HasImplibGNUtoMS(config) && gnuName.size() > 6 &&
       gnuName.substr(gnuName.size() - 6) == ".dll.a") {
     out = gnuName.substr(0, gnuName.size() - 6);
     out += newExt ? newExt : ".lib";
@@ -5375,11 +5444,14 @@ bool cmGeneratorTarget::IsExecutableWithExports() const
           this->GetPropertyAsBool("ENABLE_EXPORTS"));
 }
 
-bool cmGeneratorTarget::HasImportLibrary() const
+bool cmGeneratorTarget::HasImportLibrary(std::string const& config) const
 {
   return (this->IsDLLPlatform() &&
           (this->GetType() == cmStateEnums::SHARED_LIBRARY ||
-           this->IsExecutableWithExports()));
+           this->IsExecutableWithExports()) &&
+          // Assemblies which have only managed code do not have
+          // import libraries.
+          this->GetManagedType(config) != ManagedType::Managed);
 }
 
 std::string cmGeneratorTarget::GetSupportDirectory() const
@@ -5402,6 +5474,7 @@ bool cmGeneratorTarget::IsLinkable() const
           this->GetType() == cmStateEnums::SHARED_LIBRARY ||
           this->GetType() == cmStateEnums::MODULE_LIBRARY ||
           this->GetType() == cmStateEnums::UNKNOWN_LIBRARY ||
+          this->GetType() == cmStateEnums::OBJECT_LIBRARY ||
           this->GetType() == cmStateEnums::INTERFACE_LIBRARY ||
           this->IsExecutableWithExports());
 }
@@ -5431,3 +5504,53 @@ bool cmGeneratorTarget::IsCFBundleOnApple() const
   return (this->GetType() == cmStateEnums::MODULE_LIBRARY &&
           this->Makefile->IsOn("APPLE") && this->GetPropertyAsBool("BUNDLE"));
 }
+
+cmGeneratorTarget::ManagedType cmGeneratorTarget::CheckManagedType(
+  std::string const& propval) const
+{
+  // The type of the managed assembly (mixed unmanaged C++ and C++/CLI,
+  // or only C++/CLI) does only depend on whether the property is an empty
+  // string or contains any value at all. In Visual Studio generators
+  // this propval is prepended with /clr[:] which results in:
+  //
+  // 1. propval does not exist: no /clr flag, unmanaged target, has import
+  //                            lib
+  // 2. empty propval:          add /clr as flag, mixed unmanaged/managed
+  //                            target, has import lib
+  // 3. any value (safe,pure):  add /clr:[propval] as flag, target with
+  //                            managed code only, no import lib
+  return propval.empty() ? ManagedType::Mixed : ManagedType::Managed;
+}
+
+cmGeneratorTarget::ManagedType cmGeneratorTarget::GetManagedType(
+  const std::string& config) const
+{
+  // Only libraries and executables can be managed targets.
+  if (this->GetType() > cmStateEnums::SHARED_LIBRARY) {
+    return ManagedType::Undefined;
+  }
+
+  if (this->GetType() == cmStateEnums::STATIC_LIBRARY) {
+    return ManagedType::Native;
+  }
+
+  // Check imported target.
+  if (this->IsImported()) {
+    if (cmGeneratorTarget::ImportInfo const* info =
+          this->GetImportInfo(config)) {
+      return info->Managed;
+    }
+    return ManagedType::Undefined;
+  }
+
+  // Check for explicitly set clr target property.
+  if (auto* clr = this->GetProperty("COMMON_LANGUAGE_RUNTIME")) {
+    return this->CheckManagedType(clr);
+  }
+
+  // C# targets are always managed. This language specific check
+  // is added to avoid that the COMMON_LANGUAGE_RUNTIME target property
+  // has to be set manually for C# targets.
+  return this->HasLanguage("CSharp", config) ? ManagedType::Managed
+                                             : ManagedType::Native;
+}
diff --git a/Source/cmGeneratorTarget.h b/Source/cmGeneratorTarget.h
index 2f6ce33f1..2132b15a0 100644
--- a/Source/cmGeneratorTarget.h
+++ b/Source/cmGeneratorTarget.h
@@ -260,12 +260,12 @@ public:
                                    BundleDirectoryLevel level) const;
 
   /** Return the install name directory for the target in the
-    * build tree.  For example: "\@rpath/", "\@loader_path/",
-    * or "/full/path/to/library".  */
+   * build tree.  For example: "\@rpath/", "\@loader_path/",
+   * or "/full/path/to/library".  */
   std::string GetInstallNameDirForBuildTree(const std::string& config) const;
 
   /** Return the install name directory for the target in the
-    * install tree.  For example: "\@rpath/" or "\@loader_path/". */
+   * install tree.  For example: "\@rpath/" or "\@loader_path/". */
   std::string GetInstallNameDirForInstallTree() const;
 
   cmListFileBacktrace GetBacktrace() const;
@@ -364,6 +364,12 @@ public:
   void GetLanguages(std::set<std::string>& languages,
                     std::string const& config) const;
 
+  // Evaluate if the target uses the given language for compilation
+  // and/or linking. If 'exclusive' is true, 'language' is expected
+  // to be the only language used for the target.
+  bool HasLanguage(std::string const& language, std::string const& config,
+                   bool exclusive = true) const;
+
   void GetObjectLibrariesCMP0026(
     std::vector<cmGeneratorTarget*>& objlibs) const;
 
@@ -493,8 +499,8 @@ public:
                             cmStateEnums::ArtifactType artifact) const;
 
   /** Clears cached meta data for local and external source files.
-    * The meta data will be recomputed on demand.
-    */
+   * The meta data will be recomputed on demand.
+   */
   void ClearSourcesCache();
 
   void AddSource(const std::string& src);
@@ -566,17 +572,17 @@ public:
   std::string GetLinkerLanguage(const std::string& config) const;
 
   /** Does this target have a GNU implib to convert to MS format?  */
-  bool HasImplibGNUtoMS() const;
+  bool HasImplibGNUtoMS(std::string const& config) const;
 
   /** Convert the given GNU import library name (.dll.a) to a name with a new
       extension (.lib or ${CMAKE_IMPORT_LIBRARY_SUFFIX}).  */
-  bool GetImplibGNUtoMS(std::string const& gnuName, std::string& out,
-                        const char* newExt = nullptr) const;
+  bool GetImplibGNUtoMS(std::string const& config, std::string const& gnuName,
+                        std::string& out, const char* newExt = nullptr) const;
 
   bool IsExecutableWithExports() const;
 
   /** Return whether or not the target has a DLL import library.  */
-  bool HasImportLibrary() const;
+  bool HasImportLibrary(std::string const& config) const;
 
   /** Get a build-tree directory in which to place target support files.  */
   std::string GetSupportDirectory() const;
@@ -597,6 +603,19 @@ public:
   /** Return whether this target is a CFBundle (plugin) on Apple.  */
   bool IsCFBundleOnApple() const;
 
+  /** Assembly types. The order of the values of this enum is relevant
+      because of smaller/larger comparison operations! */
+  enum ManagedType
+  {
+    Undefined = 0, // target is no lib or executable
+    Native,        // target compiles to unmanaged binary.
+    Mixed,         // target compiles to mixed (managed and unmanaged) binary.
+    Managed        // target compiles to managed binary.
+  };
+
+  /** Return the type of assembly this target compiles to. */
+  ManagedType GetManagedType(const std::string& config) const;
+
   struct SourceFileFlags GetTargetSourceFileFlags(
     const cmSourceFile* sf) const;
 
@@ -741,10 +760,12 @@ private:
   {
     ImportInfo()
       : NoSOName(false)
+      , Managed(Native)
       , Multiplicity(0)
     {
     }
     bool NoSOName;
+    ManagedType Managed;
     unsigned int Multiplicity;
     std::string Location;
     std::string SOName;
@@ -838,6 +859,8 @@ private:
   bool ComputePDBOutputDir(const std::string& kind, const std::string& config,
                            std::string& out) const;
 
+  ManagedType CheckManagedType(std::string const& propval) const;
+
 public:
   const std::vector<const cmGeneratorTarget*>& GetLinkImplementationClosure(
     const std::string& config) const;
diff --git a/Source/cmGhsMultiTargetGenerator.cxx b/Source/cmGhsMultiTargetGenerator.cxx
index 270413c48..847230a82 100644
--- a/Source/cmGhsMultiTargetGenerator.cxx
+++ b/Source/cmGhsMultiTargetGenerator.cxx
@@ -118,8 +118,8 @@ void cmGhsMultiTargetGenerator::Generate()
     config = cmSystemTools::UpperCase(config);
     this->DynamicDownload = this->DetermineIfDynamicDownload(config, language);
     if (this->DynamicDownload) {
-      *this->GetFolderBuildStreams() << "#component integrity_dynamic_download"
-                                     << std::endl;
+      *this->GetFolderBuildStreams()
+        << "#component integrity_dynamic_download" << std::endl;
     }
     GhsMultiGpj::WriteGpjTag(this->GetGpjTag(), this->GetFolderBuildStreams());
     cmGlobalGhsMultiGenerator::WriteDisclaimer(this->GetFolderBuildStreams());
@@ -198,9 +198,9 @@ void cmGhsMultiTargetGenerator::WriteTypeSpecifics(const std::string& config,
   if (this->GeneratorTarget->GetType() == cmStateEnums::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;
+    *this->GetFolderBuildStreams()
+      << "    -o \"" << outputDir << outputFilename << static_library_suffix
+      << "\"" << std::endl;
   } else if (this->GeneratorTarget->GetType() == cmStateEnums::EXECUTABLE) {
     if (notKernel && !this->IsTargetGroup()) {
       *this->GetFolderBuildStreams() << "    -relprog" << std::endl;
@@ -208,15 +208,15 @@ void cmGhsMultiTargetGenerator::WriteTypeSpecifics(const std::string& config,
     if (this->IsTargetGroup()) {
       *this->GetFolderBuildStreams()
         << "    -o \"" << outputDir << outputFilename << ".elf\"" << std::endl;
-      *this->GetFolderBuildStreams() << "    :extraOutputFile=\"" << outputDir
-                                     << outputFilename << ".elf.ael\""
-                                     << std::endl;
+      *this->GetFolderBuildStreams()
+        << "    :extraOutputFile=\"" << outputDir << outputFilename
+        << ".elf.ael\"" << std::endl;
     } 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;
     }
   }
 }
@@ -293,8 +293,8 @@ void cmGhsMultiTargetGenerator::WriteCompilerFlags(std::string const&,
     this->FlagsByLanguage.find(language);
   if (flagsByLangI != this->FlagsByLanguage.end()) {
     if (!flagsByLangI->second.empty()) {
-      *this->GetFolderBuildStreams() << "    " << flagsByLangI->second
-                                     << std::endl;
+      *this->GetFolderBuildStreams()
+        << "    " << flagsByLangI->second << std::endl;
     }
   }
 }
@@ -321,8 +321,8 @@ void cmGhsMultiTargetGenerator::WriteIncludes(const std::string& config,
 
   for (std::vector<std::string>::const_iterator includes_i = includes.begin();
        includes_i != includes.end(); ++includes_i) {
-    *this->GetFolderBuildStreams() << "    -I\"" << *includes_i << "\""
-                                   << std::endl;
+    *this->GetFolderBuildStreams()
+      << "    -I\"" << *includes_i << "\"" << std::endl;
   }
 }
 
@@ -335,8 +335,8 @@ void cmGhsMultiTargetGenerator::WriteTargetLinkLibraries(
   for (cmTargetDependSet::iterator tdsI = tds.begin(); tdsI != tds.end();
        ++tdsI) {
     const cmGeneratorTarget* tg = *tdsI;
-    *this->GetFolderBuildStreams() << "    -L\"" << GetAbsBuildFilePath(tg)
-                                   << "\"" << std::endl;
+    *this->GetFolderBuildStreams()
+      << "    -L\"" << GetAbsBuildFilePath(tg) << "\"" << std::endl;
   }
   // library targets
   cmTarget::LinkLibraryVectorType llv =
@@ -349,8 +349,8 @@ void cmGhsMultiTargetGenerator::WriteTargetLinkLibraries(
     if (NULL != tg) {
       libName = tg->GetName() + ".a";
     }
-    *this->GetFolderBuildStreams() << "    -l\"" << libName << "\""
-                                   << std::endl;
+    *this->GetFolderBuildStreams()
+      << "    -l\"" << libName << "\"" << std::endl;
   }
 
   if (!this->TargetGroup) {
diff --git a/Source/cmGlobVerificationManager.cxx b/Source/cmGlobVerificationManager.cxx
new file mode 100644
index 000000000..e23b6eaea
--- /dev/null
+++ b/Source/cmGlobVerificationManager.cxx
@@ -0,0 +1,172 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmGlobVerificationManager.h"
+
+#include "cmsys/FStream.hxx"
+#include <sstream>
+
+#include "cmGeneratedFileStream.h"
+#include "cmListFileCache.h"
+#include "cmSystemTools.h"
+#include "cmVersion.h"
+#include "cmake.h"
+
+bool cmGlobVerificationManager::SaveVerificationScript(const std::string& path)
+{
+  if (this->Cache.empty()) {
+    return true;
+  }
+
+  std::string scriptFile = path;
+  scriptFile += cmake::GetCMakeFilesDirectory();
+  std::string stampFile = scriptFile;
+  cmSystemTools::MakeDirectory(scriptFile);
+  scriptFile += "/VerifyGlobs.cmake";
+  stampFile += "/cmake.verify_globs";
+  cmGeneratedFileStream verifyScriptFile(scriptFile.c_str());
+  verifyScriptFile.SetCopyIfDifferent(true);
+  if (!verifyScriptFile) {
+    cmSystemTools::Error("Unable to open verification script file for save. ",
+                         scriptFile.c_str());
+    cmSystemTools::ReportLastSystemError("");
+    return false;
+  }
+
+  verifyScriptFile << std::boolalpha;
+  verifyScriptFile << "# CMAKE generated file: DO NOT EDIT!\n"
+                   << "# Generated by CMake Version "
+                   << cmVersion::GetMajorVersion() << "."
+                   << cmVersion::GetMinorVersion() << "\n";
+
+  for (auto const& i : this->Cache) {
+    CacheEntryKey k = std::get<0>(i);
+    CacheEntryValue v = std::get<1>(i);
+
+    if (!v.Initialized) {
+      continue;
+    }
+
+    verifyScriptFile << "\n";
+
+    for (auto const& bt : v.Backtraces) {
+      verifyScriptFile << "# " << std::get<0>(bt);
+      std::get<1>(bt).PrintTitle(verifyScriptFile);
+      verifyScriptFile << "\n";
+    }
+
+    k.PrintGlobCommand(verifyScriptFile, "NEW_GLOB");
+    verifyScriptFile << "\n";
+
+    verifyScriptFile << "set(OLD_GLOB\n";
+    for (const std::string& file : v.Files) {
+      verifyScriptFile << "  \"" << file << "\"\n";
+    }
+    verifyScriptFile << "  )\n";
+
+    verifyScriptFile << "if(NOT \"${NEW_GLOB}\" STREQUAL \"${OLD_GLOB}\")\n"
+                     << "  message(\"-- GLOB mismatch!\")\n"
+                     << "  file(TOUCH_NOCREATE \"" << stampFile << "\")\n"
+                     << "endif()\n";
+  }
+  verifyScriptFile.Close();
+
+  cmsys::ofstream verifyStampFile(stampFile.c_str());
+  if (!verifyStampFile) {
+    cmSystemTools::Error("Unable to open verification stamp file for write. ",
+                         stampFile.c_str());
+    return false;
+  }
+  verifyStampFile << "# This file is generated by CMake for checking of the "
+                     "VerifyGlobs.cmake file\n";
+  this->VerifyScript = scriptFile;
+  this->VerifyStamp = stampFile;
+  return true;
+}
+
+bool cmGlobVerificationManager::DoWriteVerifyTarget() const
+{
+  return !this->VerifyScript.empty() && !this->VerifyStamp.empty();
+}
+
+bool cmGlobVerificationManager::CacheEntryKey::operator<(
+  const CacheEntryKey& r) const
+{
+  if (this->Recurse < r.Recurse) {
+    return true;
+  }
+  if (this->Recurse > r.Recurse) {
+    return false;
+  }
+  if (this->ListDirectories < r.ListDirectories) {
+    return true;
+  }
+  if (this->ListDirectories > r.ListDirectories) {
+    return false;
+  }
+  if (this->FollowSymlinks < r.FollowSymlinks) {
+    return true;
+  }
+  if (this->FollowSymlinks > r.FollowSymlinks) {
+    return false;
+  }
+  if (this->Relative < r.Relative) {
+    return true;
+  }
+  if (this->Relative > r.Relative) {
+    return false;
+  }
+  if (this->Expression < r.Expression) {
+    return true;
+  }
+  if (this->Expression > r.Expression) {
+    return false;
+  }
+  return false;
+}
+
+void cmGlobVerificationManager::CacheEntryKey::PrintGlobCommand(
+  std::ostream& out, const std::string& cmdVar)
+{
+  out << "file(GLOB" << (this->Recurse ? "_RECURSE " : " ");
+  out << cmdVar << " ";
+  if (this->Recurse && this->FollowSymlinks) {
+    out << "FOLLOW_SYMLINKS ";
+  }
+  out << "LIST_DIRECTORIES " << this->ListDirectories << " ";
+  if (!this->Relative.empty()) {
+    out << "RELATIVE \"" << this->Relative << "\" ";
+  }
+  out << "\"" << this->Expression << "\")";
+}
+
+void cmGlobVerificationManager::AddCacheEntry(
+  const bool recurse, const bool listDirectories, const bool followSymlinks,
+  const std::string& relative, const std::string& expression,
+  const std::vector<std::string>& files, const std::string& variable,
+  const cmListFileBacktrace& backtrace)
+{
+  CacheEntryKey key = CacheEntryKey(recurse, listDirectories, followSymlinks,
+                                    relative, expression);
+  CacheEntryValue& value = this->Cache[key];
+  if (!value.Initialized) {
+    value.Files = files;
+    value.Initialized = true;
+    value.Backtraces.emplace_back(variable, backtrace);
+  } else if (value.Initialized && value.Files != files) {
+    std::ostringstream message;
+    message << std::boolalpha;
+    message << "The glob expression\n";
+    key.PrintGlobCommand(message, variable);
+    backtrace.PrintTitle(message);
+    message << "\nwas already present in the glob cache but the directory\n"
+               "contents have changed during the configuration run.\n";
+    message << "Matching glob expressions:";
+    for (auto const& bt : value.Backtraces) {
+      message << "\n  " << std::get<0>(bt);
+      std::get<1>(bt).PrintTitle(message);
+    }
+    cmSystemTools::Error(message.str().c_str());
+  } else {
+    value.Backtraces.emplace_back(variable, backtrace);
+  }
+}
diff --git a/Source/cmGlobVerificationManager.h b/Source/cmGlobVerificationManager.h
new file mode 100644
index 000000000..4508602fe
--- /dev/null
+++ b/Source/cmGlobVerificationManager.h
@@ -0,0 +1,89 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmGlobVerificationManager_h
+#define cmGlobVerificationManager_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmListFileCache.h"
+
+#include <iosfwd>
+#include <map>
+#include <string>
+#include <utility>
+#include <vector>
+
+/** \class cmGlobVerificationManager
+ * \brief Class for expressing build-time dependencies on glob expressions.
+ *
+ * Generates a CMake script which verifies glob outputs during prebuild.
+ *
+ */
+class cmGlobVerificationManager
+{
+public:
+  cmGlobVerificationManager() {}
+
+protected:
+  ///! Save verification script for given makefile.
+  ///! Saves to output <path>/<CMakeFilesDirectory>/VerifyGlobs.cmake
+  bool SaveVerificationScript(const std::string& path);
+
+  ///! Add an entry into the glob cache
+  void AddCacheEntry(bool recurse, bool listDirectories, bool followSymlinks,
+                     const std::string& relative,
+                     const std::string& expression,
+                     const std::vector<std::string>& files,
+                     const std::string& variable,
+                     const cmListFileBacktrace& bt);
+
+  ///! Check targets should be written in generated build system.
+  bool DoWriteVerifyTarget() const;
+
+  ///! Get the paths to the generated script and stamp files
+  std::string const& GetVerifyScript() const { return this->VerifyScript; }
+  std::string const& GetVerifyStamp() const { return this->VerifyStamp; }
+
+private:
+  struct CacheEntryKey
+  {
+    const bool Recurse;
+    const bool ListDirectories;
+    const bool FollowSymlinks;
+    const std::string Relative;
+    const std::string Expression;
+    CacheEntryKey(const bool rec, const bool l, const bool s,
+                  const std::string& rel, const std::string& e)
+      : Recurse(rec)
+      , ListDirectories(l)
+      , FollowSymlinks(s)
+      , Relative(rel)
+      , Expression(e)
+    {
+    }
+    bool operator<(const CacheEntryKey& r) const;
+    void PrintGlobCommand(std::ostream& out, const std::string& cmdVar);
+  };
+
+  struct CacheEntryValue
+  {
+    bool Initialized;
+    std::vector<std::string> Files;
+    std::vector<std::pair<std::string, cmListFileBacktrace>> Backtraces;
+    CacheEntryValue()
+      : Initialized(false)
+    {
+    }
+  };
+
+  typedef std::map<CacheEntryKey, CacheEntryValue> CacheEntryMap;
+  CacheEntryMap Cache;
+  std::string VerifyScript;
+  std::string VerifyStamp;
+
+  // Only cmState should be able to add cache values.
+  // cmGlobVerificationManager should never be used directly.
+  friend class cmState; // allow access to add cache values
+};
+
+#endif
diff --git a/Source/cmGlobalBorlandMakefileGenerator.cxx b/Source/cmGlobalBorlandMakefileGenerator.cxx
index d2372a766..23891031b 100644
--- a/Source/cmGlobalBorlandMakefileGenerator.cxx
+++ b/Source/cmGlobalBorlandMakefileGenerator.cxx
@@ -51,3 +51,32 @@ void cmGlobalBorlandMakefileGenerator::GetDocumentation(
   entry.Name = cmGlobalBorlandMakefileGenerator::GetActualName();
   entry.Brief = "Generates Borland makefiles.";
 }
+
+void cmGlobalBorlandMakefileGenerator::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,
+  int /*jobs*/, bool verbose, std::vector<std::string> const& makeOptions)
+{
+  this->cmGlobalUnixMakefileGenerator3::GenerateBuildCommand(
+    makeCommand, makeProgram, projectName, projectDir, targetName, config,
+    fast, cmake::NO_BUILD_PARALLEL_LEVEL, verbose, makeOptions);
+}
+
+void cmGlobalBorlandMakefileGenerator::PrintBuildCommandAdvice(
+  std::ostream& os, int jobs) const
+{
+  if (jobs != cmake::NO_BUILD_PARALLEL_LEVEL) {
+    // Borland's make does not support parallel builds
+    // see http://docwiki.embarcadero.com/RADStudio/Tokyo/en/Make
+
+    /* clang-format off */
+    os <<
+      "Warning: Borland's make does not support parallel builds. "
+      "Ignoring parallel build command line option.\n";
+    /* clang-format on */
+  }
+
+  this->cmGlobalUnixMakefileGenerator3::PrintBuildCommandAdvice(
+    os, cmake::NO_BUILD_PARALLEL_LEVEL);
+}
diff --git a/Source/cmGlobalBorlandMakefileGenerator.h b/Source/cmGlobalBorlandMakefileGenerator.h
index 5578d7646..27de6cc6c 100644
--- a/Source/cmGlobalBorlandMakefileGenerator.h
+++ b/Source/cmGlobalBorlandMakefileGenerator.h
@@ -5,6 +5,8 @@
 
 #include "cmGlobalNMakeMakefileGenerator.h"
 
+#include <iosfwd>
+
 /** \class cmGlobalBorlandMakefileGenerator
  * \brief Write a Borland makefiles.
  *
@@ -21,7 +23,7 @@ public:
   }
 
   ///! Get the name for the generator.
-  virtual std::string GetName() const
+  std::string GetName() const override
   {
     return cmGlobalBorlandMakefileGenerator::GetActualName();
   }
@@ -31,17 +33,30 @@ public:
   static void GetDocumentation(cmDocumentationEntry& entry);
 
   ///! Create a local generator appropriate to this Global Generator
-  virtual cmLocalGenerator* CreateLocalGenerator(cmMakefile* mf);
+  cmLocalGenerator* CreateLocalGenerator(cmMakefile* mf) override;
 
   /**
    * 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 bool AllowNotParallel() const { return false; }
-  virtual bool AllowDeleteOnError() const { return false; }
+  void EnableLanguage(std::vector<std::string> const& languages, cmMakefile*,
+                      bool optional) override;
+
+  bool AllowNotParallel() const override { return false; }
+  bool AllowDeleteOnError() const override { return false; }
+
+protected:
+  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, int jobs,
+                            bool verbose,
+                            std::vector<std::string> const& makeOptions =
+                              std::vector<std::string>()) override;
+
+  void PrintBuildCommandAdvice(std::ostream& os, int jobs) const override;
 };
 
 #endif
diff --git a/Source/cmGlobalGenerator.cxx b/Source/cmGlobalGenerator.cxx
index c805b98d7..2872831c6 100644
--- a/Source/cmGlobalGenerator.cxx
+++ b/Source/cmGlobalGenerator.cxx
@@ -6,14 +6,14 @@
 #include "cmsys/FStream.hxx"
 #include <algorithm>
 #include <assert.h>
+#include <cstring>
 #include <iterator>
 #include <sstream>
 #include <stdio.h>
 #include <stdlib.h>
-#include <string.h>
 
 #if defined(_WIN32) && !defined(__CYGWIN__)
-#include <windows.h>
+#  include <windows.h>
 #endif
 
 #include "cmAlgorithms.h"
@@ -44,13 +44,13 @@
 #include "cmake.h"
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
-#include "cmCryptoHash.h"
-#include "cm_jsoncpp_value.h"
-#include "cm_jsoncpp_writer.h"
+#  include "cmCryptoHash.h"
+#  include "cm_jsoncpp_value.h"
+#  include "cm_jsoncpp_writer.h"
 #endif
 
 #if defined(_MSC_VER) && _MSC_VER >= 1800
-#define KWSYS_WINDOWS_DEPRECATED_GetVersionEx
+#  define KWSYS_WINDOWS_DEPRECATED_GetVersionEx
 #endif
 
 const std::string kCMAKE_PLATFORM_INFO_INITIALIZED =
@@ -442,8 +442,9 @@ void cmGlobalGenerator::EnableLanguage(
   for (std::string const& li : cur_languages) {
     if (!this->LanguagesInProgress.insert(li).second) {
       std::ostringstream e;
-      e << "Language '" << li << "' is currently being enabled.  "
-                                 "Recursive call not allowed.";
+      e << "Language '" << li
+        << "' is currently being enabled.  "
+           "Recursive call not allowed.";
       mf->IssueMessage(cmake::FATAL_ERROR, e.str());
       cmSystemTools::SetFatalErrorOccured();
       return;
@@ -523,14 +524,14 @@ void cmGlobalGenerator::EnableLanguage(
     ZeroMemory(&osviex, sizeof(osviex));
     osviex.dwOSVersionInfoSize = sizeof(osviex);
 
-#ifdef KWSYS_WINDOWS_DEPRECATED_GetVersionEx
-#pragma warning(push)
-#pragma warning(disable : 4996)
-#endif
+#  ifdef KWSYS_WINDOWS_DEPRECATED_GetVersionEx
+#    pragma warning(push)
+#    pragma warning(disable : 4996)
+#  endif
     GetVersionExW((OSVERSIONINFOW*)&osviex);
-#ifdef KWSYS_WINDOWS_DEPRECATED_GetVersionEx
-#pragma warning(pop)
-#endif
+#  ifdef KWSYS_WINDOWS_DEPRECATED_GetVersionEx
+#    pragma warning(pop)
+#  endif
     std::ostringstream windowsVersionString;
     windowsVersionString << osviex.dwMajorVersion << "."
                          << osviex.dwMinorVersion << "."
@@ -1403,7 +1404,8 @@ void cmGlobalGenerator::Generate()
     }
     this->LocalGenerators[i]->GenerateTestFiles();
     this->CMakeInstance->UpdateProgress(
-      "Generating", (static_cast<float>(i) + 1.0f) /
+      "Generating",
+      (static_cast<float>(i) + 1.0f) /
         static_cast<float>(this->LocalGenerators.size()));
   }
   this->SetCurrentMakefile(nullptr);
@@ -1560,8 +1562,8 @@ void cmGlobalGenerator::FinalizeTargetCompileInfo()
 
       cmBacktraceRange::const_iterator btIt =
         noconfig_compile_definitions_bts.begin();
-      for (cmStringRange::const_iterator
-             it = noconfig_compile_definitions.begin();
+      for (cmStringRange::const_iterator it =
+             noconfig_compile_definitions.begin();
            it != noconfig_compile_definitions.end(); ++it, ++btIt) {
         t->InsertCompileDefinition(*it, *btIt);
       }
@@ -1721,7 +1723,8 @@ void cmGlobalGenerator::CheckTargetProperties()
       }
     }
     this->CMakeInstance->UpdateProgress(
-      "Configuring", 0.9f +
+      "Configuring",
+      0.9f +
         0.1f * (static_cast<float>(i) + 1.0f) /
           static_cast<float>(this->Makefiles.size()));
   }
@@ -1741,7 +1744,7 @@ void cmGlobalGenerator::CheckTargetProperties()
   }
 }
 
-int cmGlobalGenerator::TryCompile(const std::string& srcdir,
+int cmGlobalGenerator::TryCompile(int jobs, const std::string& srcdir,
                                   const std::string& bindir,
                                   const std::string& projectName,
                                   const std::string& target, bool fast,
@@ -1769,7 +1772,7 @@ int cmGlobalGenerator::TryCompile(const std::string& srcdir,
   if (!target.empty()) {
     newTarget += target;
 #if 0
-#if defined(_WIN32) || defined(__CYGWIN__)
+#  if defined(_WIN32) || defined(__CYGWIN__)
     std::string tmp = target;
     // if the target does not already end in . something
     // then assume .exe
@@ -1777,12 +1780,12 @@ int cmGlobalGenerator::TryCompile(const std::string& srcdir,
       {
       newTarget += ".exe";
       }
-#endif // WIN32
+#  endif // WIN32
 #endif
   }
   std::string config =
     mf->GetSafeDefinition("CMAKE_TRY_COMPILE_CONFIGURATION");
-  return this->Build(srcdir, bindir, projectName, newTarget, output, "",
+  return this->Build(jobs, srcdir, bindir, projectName, newTarget, output, "",
                      config, false, fast, false, this->TryCompileTimeout);
 }
 
@@ -1790,13 +1793,21 @@ void cmGlobalGenerator::GenerateBuildCommand(
   std::vector<std::string>& makeCommand, const std::string& /*unused*/,
   const std::string& /*unused*/, const std::string& /*unused*/,
   const std::string& /*unused*/, const std::string& /*unused*/,
-  bool /*unused*/, bool /*unused*/, std::vector<std::string> const& /*unused*/)
+  bool /*unused*/, int /*unused*/, bool /*unused*/,
+  std::vector<std::string> const& /*unused*/)
 {
   makeCommand.push_back(
     "cmGlobalGenerator::GenerateBuildCommand not implemented");
 }
 
-int cmGlobalGenerator::Build(const std::string& /*unused*/,
+void cmGlobalGenerator::PrintBuildCommandAdvice(std::ostream& /*os*/,
+                                                int /*jobs*/) const
+{
+  // Subclasses override this method if they e.g want to give a warning that
+  // they do not support certain build command line options
+}
+
+int cmGlobalGenerator::Build(int jobs, const std::string& /*unused*/,
                              const std::string& bindir,
                              const std::string& projectName,
                              const std::string& target, std::string& output,
@@ -1806,6 +1817,8 @@ int cmGlobalGenerator::Build(const std::string& /*unused*/,
                              cmSystemTools::OutputOption outputflag,
                              std::vector<std::string> const& nativeOptions)
 {
+  bool hideconsole = cmSystemTools::GetRunCommandHideConsole();
+
   /**
    * Run an executable command and put the stdout in output.
    */
@@ -1813,16 +1826,25 @@ int cmGlobalGenerator::Build(const std::string& /*unused*/,
   output += "Change Dir: ";
   output += bindir;
   output += "\n";
+  if (workdir.Failed()) {
+    cmSystemTools::SetRunCommandHideConsole(hideconsole);
+    cmSystemTools::Error("Failed to change directory: ",
+                         std::strerror(workdir.GetLastResult()));
+    output += "Failed to change directory: ";
+    output += std::strerror(workdir.GetLastResult());
+    output += "\n";
+    return 1;
+  }
 
   int retVal;
-  bool hideconsole = cmSystemTools::GetRunCommandHideConsole();
   cmSystemTools::SetRunCommandHideConsole(true);
   std::string outputBuffer;
   std::string* outputPtr = &outputBuffer;
 
   std::vector<std::string> makeCommand;
   this->GenerateBuildCommand(makeCommand, makeCommandCSTR, projectName, bindir,
-                             target, config, fast, verbose, nativeOptions);
+                             target, config, fast, jobs, verbose,
+                             nativeOptions);
 
   // Workaround to convince VCExpress.exe to produce output.
   if (outputflag == cmSystemTools::OUTPUT_PASSTHROUGH &&
@@ -1836,7 +1858,7 @@ int cmGlobalGenerator::Build(const std::string& /*unused*/,
   if (clean) {
     std::vector<std::string> cleanCommand;
     this->GenerateBuildCommand(cleanCommand, makeCommandCSTR, projectName,
-                               bindir, "clean", config, fast, verbose);
+                               bindir, "clean", config, fast, jobs, verbose);
     output += "\nRun Clean Command:";
     output += cmSystemTools::PrintSingleCommand(cleanCommand);
     output += "\n";
@@ -1883,6 +1905,13 @@ int cmGlobalGenerator::Build(const std::string& /*unused*/,
     retVal = 1;
   }
 
+  // The OpenWatcom tools do not return an error code when a link
+  // library is not found!
+  if (this->CMakeInstance->GetState()->UseWatcomWMake() && retVal == 0 &&
+      output.find("W1008: cannot open") != std::string::npos) {
+    retVal = 1;
+  }
+
   return retVal;
 }
 
@@ -2440,8 +2469,9 @@ void cmGlobalGenerator::AddGlobalTarget_Install(
   bool skipInstallRules = mf->IsOn("CMAKE_SKIP_INSTALL_RULES");
   if (this->InstallTargetEnabled && skipInstallRules) {
     this->CMakeInstance->IssueMessage(
-      cmake::WARNING, "CMAKE_SKIP_INSTALL_RULES was enabled even though "
-                      "installation rules have been specified",
+      cmake::WARNING,
+      "CMAKE_SKIP_INSTALL_RULES was enabled even though "
+      "installation rules have been specified",
       mf->GetBacktrace());
   } else if (this->InstallTargetEnabled && !skipInstallRules) {
     if (!cmakeCfgIntDir || !*cmakeCfgIntDir || cmakeCfgIntDir[0] == '.') {
diff --git a/Source/cmGlobalGenerator.h b/Source/cmGlobalGenerator.h
index 34ed5b0e6..a50cc3bb3 100644
--- a/Source/cmGlobalGenerator.h
+++ b/Source/cmGlobalGenerator.h
@@ -23,7 +23,7 @@
 #include "cm_codecvt.hxx"
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
-#include "cmFileLockPool.h"
+#  include "cmFileLockPool.h"
 #endif
 
 class cmExportBuildFileGenerator;
@@ -147,9 +147,10 @@ public:
    * 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);
+  int TryCompile(int jobs, const std::string& srcdir,
+                 const std::string& bindir, 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
@@ -157,14 +158,15 @@ public:
    * empty then all is assumed. clean indicates if a "make clean" should be
    * done first.
    */
-  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,
-            cmDuration timeout, cmSystemTools::OutputOption outputflag =
-                                  cmSystemTools::OUTPUT_NONE,
-            std::vector<std::string> const& nativeOptions =
-              std::vector<std::string>());
+  int Build(
+    int jobs, 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,
+    cmDuration timeout,
+    cmSystemTools::OutputOption outputflag = cmSystemTools::OUTPUT_NONE,
+    std::vector<std::string> const& nativeOptions =
+      std::vector<std::string>());
 
   /**
    * Open a generated IDE project given the following information.
@@ -176,9 +178,11 @@ public:
     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,
+    int jobs, bool verbose,
     std::vector<std::string> const& makeOptions = std::vector<std::string>());
 
+  virtual void PrintBuildCommandAdvice(std::ostream& os, int jobs) const;
+
   /** Generate a "cmake --build" call for a given target and config.  */
   std::string GenerateCMakeBuildCommand(const std::string& target,
                                         const std::string& config,
diff --git a/Source/cmGlobalGhsMultiGenerator.cxx b/Source/cmGlobalGhsMultiGenerator.cxx
index 946ed80ca..0328991e6 100644
--- a/Source/cmGlobalGhsMultiGenerator.cxx
+++ b/Source/cmGlobalGhsMultiGenerator.cxx
@@ -273,11 +273,18 @@ 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)
+  int jobs, bool /*verbose*/, std::vector<std::string> const& makeOptions)
 {
   makeCommand.push_back(
     this->SelectMakeProgram(makeProgram, this->GetGhsBuildCommand()));
 
+  if (jobs != cmake::NO_BUILD_PARALLEL_LEVEL) {
+    makeCommand.push_back("-parallel");
+    if (jobs != cmake::DEFAULT_BUILD_PARALLEL_LEVEL) {
+      makeCommand.push_back(std::to_string(jobs));
+    }
+  }
+
   makeCommand.insert(makeCommand.end(), makeOptions.begin(),
                      makeOptions.end());
   if (!targetName.empty()) {
@@ -306,8 +313,8 @@ void cmGlobalGhsMultiGenerator::WriteMacros()
 
 void cmGlobalGhsMultiGenerator::WriteHighLevelDirectives()
 {
-  *this->GetBuildFileStream() << "primaryTarget=arm_integrity.tgt"
-                              << std::endl;
+  *this->GetBuildFileStream()
+    << "primaryTarget=arm_integrity.tgt" << std::endl;
   char const* const customization =
     this->GetCMakeInstance()->GetCacheDefinition("GHS_CUSTOMIZATION");
   if (NULL != customization && strlen(customization) > 0) {
@@ -319,8 +326,8 @@ void cmGlobalGhsMultiGenerator::WriteHighLevelDirectives()
 
 void cmGlobalGhsMultiGenerator::WriteCompilerOptions(std::string const& fOSDir)
 {
-  *this->GetBuildFileStream() << "    -os_dir=\"" << fOSDir << "\""
-                              << std::endl;
+  *this->GetBuildFileStream()
+    << "    -os_dir=\"" << fOSDir << "\"" << std::endl;
 }
 
 void cmGlobalGhsMultiGenerator::WriteDisclaimer(std::ostream* os)
diff --git a/Source/cmGlobalGhsMultiGenerator.h b/Source/cmGlobalGhsMultiGenerator.h
index 7d4b2ba7f..30d4d3b27 100644
--- a/Source/cmGlobalGhsMultiGenerator.h
+++ b/Source/cmGlobalGhsMultiGenerator.h
@@ -49,14 +49,14 @@ public:
   static bool SupportsPlatform() { return false; }
 
   /**
-  * Try to determine system information such as shared library
-  * extension, pthreads, byte order etc.
-  */
+   * 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);
   /*
-  * Determine what program to use for building the project.
-  */
+   * Determine what program to use for building the project.
+   */
   bool FindMakeProgram(cmMakefile* mf) override;
 
   cmGeneratedFileStream* GetBuildFileStream()
@@ -89,7 +89,7 @@ protected:
     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,
+    int jobs, bool verbose,
     std::vector<std::string> const& makeOptions = std::vector<std::string>());
 
 private:
diff --git a/Source/cmGlobalJOMMakefileGenerator.cxx b/Source/cmGlobalJOMMakefileGenerator.cxx
index 18c45e0d8..0f41ea148 100644
--- a/Source/cmGlobalJOMMakefileGenerator.cxx
+++ b/Source/cmGlobalJOMMakefileGenerator.cxx
@@ -52,3 +52,29 @@ void cmGlobalJOMMakefileGenerator::PrintCompilerAdvice(
   }
   this->cmGlobalUnixMakefileGenerator3::PrintCompilerAdvice(os, lang, envVar);
 }
+
+void cmGlobalJOMMakefileGenerator::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,
+  int jobs, bool verbose, std::vector<std::string> const& makeOptions)
+{
+  std::vector<std::string> jomMakeOptions;
+
+  // Since we have full control over the invocation of JOM, let us
+  // make it quiet.
+  jomMakeOptions.push_back(this->MakeSilentFlag);
+  jomMakeOptions.insert(jomMakeOptions.end(), makeOptions.begin(),
+                        makeOptions.end());
+
+  // JOM does parallel builds by default, the -j is only needed if a specific
+  // number is given
+  // see https://github.com/qt-labs/jom/blob/v1.1.2/src/jomlib/options.cpp
+  if (jobs == cmake::DEFAULT_BUILD_PARALLEL_LEVEL) {
+    jobs = cmake::NO_BUILD_PARALLEL_LEVEL;
+  }
+
+  cmGlobalUnixMakefileGenerator3::GenerateBuildCommand(
+    makeCommand, makeProgram, projectName, projectDir, targetName, config,
+    fast, jobs, verbose, jomMakeOptions);
+}
diff --git a/Source/cmGlobalJOMMakefileGenerator.h b/Source/cmGlobalJOMMakefileGenerator.h
index 2e8ee2939..bcf46d031 100644
--- a/Source/cmGlobalJOMMakefileGenerator.h
+++ b/Source/cmGlobalJOMMakefileGenerator.h
@@ -5,6 +5,8 @@
 
 #include "cmGlobalUnixMakefileGenerator3.h"
 
+#include <iosfwd>
+
 /** \class cmGlobalJOMMakefileGenerator
  * \brief Write a JOM makefiles.
  *
@@ -19,7 +21,7 @@ public:
     return new cmGlobalGeneratorSimpleFactory<cmGlobalJOMMakefileGenerator>();
   }
   ///! Get the name for the generator.
-  virtual std::string GetName() const
+  std::string GetName() const override
   {
     return cmGlobalJOMMakefileGenerator::GetActualName();
   }
@@ -34,12 +36,23 @@ 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);
+  void EnableLanguage(std::vector<std::string> const& languages, cmMakefile*,
+                      bool optional) override;
+
+protected:
+  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, int jobs,
+                            bool verbose,
+                            std::vector<std::string> const& makeOptions =
+                              std::vector<std::string>()) override;
 
 private:
   void PrintCompilerAdvice(std::ostream& os, std::string const& lang,
-                           const char* envVar) const;
+                           const char* envVar) const override;
 };
 
 #endif
diff --git a/Source/cmGlobalNMakeMakefileGenerator.cxx b/Source/cmGlobalNMakeMakefileGenerator.cxx
index da683fb39..eb66bd12b 100644
--- a/Source/cmGlobalNMakeMakefileGenerator.cxx
+++ b/Source/cmGlobalNMakeMakefileGenerator.cxx
@@ -52,3 +52,40 @@ void cmGlobalNMakeMakefileGenerator::PrintCompilerAdvice(
   }
   this->cmGlobalUnixMakefileGenerator3::PrintCompilerAdvice(os, lang, envVar);
 }
+
+void cmGlobalNMakeMakefileGenerator::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,
+  int /*jobs*/, bool verbose, std::vector<std::string> const& makeOptions)
+{
+  std::vector<std::string> nmakeMakeOptions;
+
+  // Since we have full control over the invocation of nmake, let us
+  // make it quiet.
+  nmakeMakeOptions.push_back(this->MakeSilentFlag);
+  nmakeMakeOptions.insert(nmakeMakeOptions.end(), makeOptions.begin(),
+                          makeOptions.end());
+
+  this->cmGlobalUnixMakefileGenerator3::GenerateBuildCommand(
+    makeCommand, makeProgram, projectName, projectDir, targetName, config,
+    fast, cmake::NO_BUILD_PARALLEL_LEVEL, verbose, nmakeMakeOptions);
+}
+
+void cmGlobalNMakeMakefileGenerator::PrintBuildCommandAdvice(std::ostream& os,
+                                                             int jobs) const
+{
+  if (jobs != cmake::NO_BUILD_PARALLEL_LEVEL) {
+    // nmake does not support parallel build level
+    // see https://msdn.microsoft.com/en-us/library/afyyse50.aspx
+
+    /* clang-format off */
+    os <<
+      "Warning: NMake does not support parallel builds. "
+      "Ignoring parallel build command line option.\n";
+    /* clang-format on */
+  }
+
+  this->cmGlobalUnixMakefileGenerator3::PrintBuildCommandAdvice(
+    os, cmake::NO_BUILD_PARALLEL_LEVEL);
+}
diff --git a/Source/cmGlobalNMakeMakefileGenerator.h b/Source/cmGlobalNMakeMakefileGenerator.h
index 05ab90435..62dea6ebc 100644
--- a/Source/cmGlobalNMakeMakefileGenerator.h
+++ b/Source/cmGlobalNMakeMakefileGenerator.h
@@ -5,6 +5,8 @@
 
 #include "cmGlobalUnixMakefileGenerator3.h"
 
+#include <iosfwd>
+
 /** \class cmGlobalNMakeMakefileGenerator
  * \brief Write a NMake makefiles.
  *
@@ -20,7 +22,7 @@ public:
       cmGlobalNMakeMakefileGenerator>();
   }
   ///! Get the name for the generator.
-  virtual std::string GetName() const
+  std::string GetName() const override
   {
     return cmGlobalNMakeMakefileGenerator::GetActualName();
   }
@@ -39,12 +41,25 @@ 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);
+  void EnableLanguage(std::vector<std::string> const& languages, cmMakefile*,
+                      bool optional) override;
+
+protected:
+  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, int jobs,
+                            bool verbose,
+                            std::vector<std::string> const& makeOptions =
+                              std::vector<std::string>()) override;
+
+  void PrintBuildCommandAdvice(std::ostream& os, int jobs) const override;
 
 private:
   void PrintCompilerAdvice(std::ostream& os, std::string const& lang,
-                           const char* envVar) const;
+                           const char* envVar) const override;
 };
 
 #endif
diff --git a/Source/cmGlobalNinjaGenerator.cxx b/Source/cmGlobalNinjaGenerator.cxx
index b251f86a7..6f7e82ab1 100644
--- a/Source/cmGlobalNinjaGenerator.cxx
+++ b/Source/cmGlobalNinjaGenerator.cxx
@@ -101,31 +101,6 @@ std::string cmGlobalNinjaGenerator::EncodeRuleName(std::string const& name)
   return encoded;
 }
 
-static bool IsIdentChar(char 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)
-{
-  if (std::find_if(ident.begin(), ident.end(),
-                   [](char c) { return !IsIdentChar(c); }) != ident.end()) {
-    static unsigned VarNum = 0;
-    std::ostringstream names;
-    names << "ident" << VarNum++;
-    vars << names.str() << " = " << ident << "\n";
-    return "$" + names.str();
-  }
-  std::string result = ident;
-  cmSystemTools::ReplaceString(result, " ", "$ ");
-  cmSystemTools::ReplaceString(result, ":", "$:");
-  return result;
-}
-
 std::string cmGlobalNinjaGenerator::EncodeLiteral(const std::string& lit)
 {
   std::string result = lit;
@@ -143,7 +118,10 @@ std::string cmGlobalNinjaGenerator::EncodePath(const std::string& path)
   else
     std::replace(result.begin(), result.end(), '/', '\\');
 #endif
-  return EncodeLiteral(result);
+  result = EncodeLiteral(result);
+  cmSystemTools::ReplaceString(result, " ", "$ ");
+  cmSystemTools::ReplaceString(result, ":", "$:");
+  return result;
 }
 
 void cmGlobalNinjaGenerator::WriteBuild(
@@ -177,14 +155,14 @@ void cmGlobalNinjaGenerator::WriteBuild(
 
   // Write explicit dependencies.
   for (std::string const& explicitDep : explicitDeps) {
-    arguments += " " + EncodeIdent(EncodePath(explicitDep), os);
+    arguments += " " + EncodePath(explicitDep);
   }
 
   // Write implicit dependencies.
   if (!implicitDeps.empty()) {
     arguments += " |";
     for (std::string const& implicitDep : implicitDeps) {
-      arguments += " " + EncodeIdent(EncodePath(implicitDep), os);
+      arguments += " " + EncodePath(implicitDep);
     }
   }
 
@@ -192,7 +170,7 @@ void cmGlobalNinjaGenerator::WriteBuild(
   if (!orderOnlyDeps.empty()) {
     arguments += " ||";
     for (std::string const& orderOnlyDep : orderOnlyDeps) {
-      arguments += " " + EncodeIdent(EncodePath(orderOnlyDep), os);
+      arguments += " " + EncodePath(orderOnlyDep);
     }
   }
 
@@ -203,7 +181,7 @@ void cmGlobalNinjaGenerator::WriteBuild(
   // Write outputs files.
   build += "build";
   for (std::string const& output : outputs) {
-    build += " " + EncodeIdent(EncodePath(output), os);
+    build += " " + EncodePath(output);
     if (this->ComputingUnknownDependencies) {
       this->CombinedBuildOutputs.insert(output);
     }
@@ -211,7 +189,7 @@ void cmGlobalNinjaGenerator::WriteBuild(
   if (!implicitOuts.empty()) {
     build += " |";
     for (std::string const& implicitOut : implicitOuts) {
-      build += " " + EncodeIdent(EncodePath(implicitOut), os);
+      build += " " + EncodePath(implicitOut);
     }
   }
   build += ":";
@@ -475,6 +453,7 @@ cmGlobalNinjaGenerator::cmGlobalNinjaGenerator(cmake* cm)
   , PolicyCMP0058(cmPolicies::WARN)
   , NinjaSupportsConsolePool(false)
   , NinjaSupportsImplicitOuts(false)
+  , NinjaSupportsManifestRestat(false)
   , NinjaSupportsDyndeps(0)
 {
 #ifdef _WIN32
@@ -576,9 +555,10 @@ bool cmGlobalNinjaGenerator::FindMakeProgram(cmMakefile* mf)
     if (!cmSystemTools::RunSingleCommand(command, &version, &error, nullptr,
                                          nullptr,
                                          cmSystemTools::OUTPUT_NONE)) {
-      mf->IssueMessage(cmake::FATAL_ERROR, "Running\n '" +
-                         cmJoin(command, "' '") + "'\n"
-                                                  "failed with:\n " +
+      mf->IssueMessage(cmake::FATAL_ERROR,
+                       "Running\n '" + cmJoin(command, "' '") +
+                         "'\n"
+                         "failed with:\n " +
                          error);
       cmSystemTools::SetFatalErrorOccured();
       return false;
@@ -597,6 +577,9 @@ void cmGlobalNinjaGenerator::CheckNinjaFeatures()
   this->NinjaSupportsImplicitOuts = !cmSystemTools::VersionCompare(
     cmSystemTools::OP_LESS, this->NinjaVersion.c_str(),
     this->RequiredNinjaVersionForImplicitOuts().c_str());
+  this->NinjaSupportsManifestRestat = !cmSystemTools::VersionCompare(
+    cmSystemTools::OP_LESS, this->NinjaVersion.c_str(),
+    RequiredNinjaVersionForManifestRestat().c_str());
   {
     // Our ninja branch adds ".dyndep-#" to its version number,
     // where '#' is a feature-specific version number.  Extract it.
@@ -692,7 +675,7 @@ 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)
+  int jobs, bool verbose, std::vector<std::string> const& makeOptions)
 {
   makeCommand.push_back(this->SelectMakeProgram(makeProgram));
 
@@ -700,6 +683,12 @@ void cmGlobalNinjaGenerator::GenerateBuildCommand(
     makeCommand.push_back("-v");
   }
 
+  if ((jobs != cmake::NO_BUILD_PARALLEL_LEVEL) &&
+      (jobs != cmake::DEFAULT_BUILD_PARALLEL_LEVEL)) {
+    makeCommand.push_back("-j");
+    makeCommand.push_back(std::to_string(jobs));
+  }
+
   makeCommand.insert(makeCommand.end(), makeOptions.begin(),
                      makeOptions.end());
   if (!targetName.empty()) {
@@ -949,12 +938,14 @@ void cmGlobalNinjaGenerator::AddDependencyToAll(const std::string& input)
 void cmGlobalNinjaGenerator::WriteAssumedSourceDependencies()
 {
   for (auto const& asd : this->AssumedSourceDependencies) {
-    cmNinjaDeps deps;
-    std::copy(asd.second.begin(), asd.second.end(), std::back_inserter(deps));
+    cmNinjaDeps orderOnlyDeps;
+    std::copy(asd.second.begin(), asd.second.end(),
+              std::back_inserter(orderOnlyDeps));
     WriteCustomCommandBuild(/*command=*/"", /*description=*/"",
                             "Assume dependencies for generated source file.",
                             /*depfile*/ "", /*uses_terminal*/ false,
-                            /*restat*/ true, cmNinjaDeps(1, asd.first), deps);
+                            /*restat*/ true, cmNinjaDeps(1, asd.first),
+                            cmNinjaDeps(), orderOnlyDeps);
   }
 }
 
@@ -1223,11 +1214,13 @@ void cmGlobalNinjaGenerator::WriteUnknownExplicitDependencies(std::ostream& os)
     for (std::string const& file : files) {
       knownDependencies.insert(this->ConvertToNinjaPath(file));
     }
-    // get list files which are implicit dependencies as well and will be phony
-    // for rebuild manifest
-    std::vector<std::string> const& lf = lg->GetMakefile()->GetListFiles();
-    for (std::string const& j : lf) {
-      knownDependencies.insert(this->ConvertToNinjaPath(j));
+    if (!this->GlobalSettingIsOn("CMAKE_SUPPRESS_REGENERATION")) {
+      // get list files which are implicit dependencies as well and will be
+      // phony for rebuild manifest
+      std::vector<std::string> const& lf = lg->GetMakefile()->GetListFiles();
+      for (std::string const& j : lf) {
+        knownDependencies.insert(this->ConvertToNinjaPath(j));
+      }
     }
     std::vector<cmGeneratorExpressionEvaluationFile*> const& ef =
       lg->GetMakefile()->GetEvaluationFiles();
@@ -1335,6 +1328,9 @@ void cmGlobalNinjaGenerator::WriteTargetAll(std::ostream& os)
 
 void cmGlobalNinjaGenerator::WriteTargetRebuildManifest(std::ostream& os)
 {
+  if (this->GlobalSettingIsOn("CMAKE_SUPPRESS_REGENERATION")) {
+    return;
+  }
   cmLocalGenerator* lg = this->LocalGenerators[0];
 
   std::ostringstream cmd;
@@ -1356,6 +1352,7 @@ void cmGlobalNinjaGenerator::WriteTargetRebuildManifest(std::ostream& os)
             /*generator=*/true);
 
   cmNinjaDeps implicitDeps;
+  cmNinjaDeps explicitDeps;
   for (cmLocalGenerator* localGen : this->LocalGenerators) {
     std::vector<std::string> const& lf =
       localGen->GetMakefile()->GetListFiles();
@@ -1365,10 +1362,6 @@ void cmGlobalNinjaGenerator::WriteTargetRebuildManifest(std::ostream& os)
   }
   implicitDeps.push_back(this->CMakeCacheFile);
 
-  std::sort(implicitDeps.begin(), implicitDeps.end());
-  implicitDeps.erase(std::unique(implicitDeps.begin(), implicitDeps.end()),
-                     implicitDeps.end());
-
   cmNinjaVars variables;
   // Use 'console' pool to get non buffered output of the CMake re-run call
   // Available since Ninja 1.5
@@ -1376,16 +1369,81 @@ void cmGlobalNinjaGenerator::WriteTargetRebuildManifest(std::ostream& os)
     variables["pool"] = "console";
   }
 
+  cmake* cm = this->GetCMakeInstance();
+  if (this->SupportsManifestRestat() && cm->DoWriteGlobVerifyTarget()) {
+    std::ostringstream verify_cmd;
+    verify_cmd << lg->ConvertToOutputFormat(cmSystemTools::GetCMakeCommand(),
+                                            cmOutputConverter::SHELL)
+               << " -P "
+               << lg->ConvertToOutputFormat(cm->GetGlobVerifyScript(),
+                                            cmOutputConverter::SHELL);
+
+    WriteRule(*this->RulesFileStream, "VERIFY_GLOBS", verify_cmd.str(),
+              "Re-checking globbed directories...",
+              "Rule for re-checking globbed directories.",
+              /*depfile=*/"",
+              /*deptype=*/"",
+              /*rspfile=*/"",
+              /*rspcontent*/ "",
+              /*restat=*/"",
+              /*generator=*/true);
+
+    std::string verifyForce = cm->GetGlobVerifyScript() + "_force";
+    cmNinjaDeps verifyForceDeps(1, this->NinjaOutputPath(verifyForce));
+
+    this->WritePhonyBuild(os, "Phony target to force glob verification run.",
+                          verifyForceDeps, cmNinjaDeps());
+
+    variables["restat"] = "1";
+    std::string const verifyScriptFile =
+      this->NinjaOutputPath(cm->GetGlobVerifyScript());
+    std::string const verifyStampFile =
+      this->NinjaOutputPath(cm->GetGlobVerifyStamp());
+    this->WriteBuild(os,
+                     "Re-run CMake to check if globbed directories changed.",
+                     "VERIFY_GLOBS",
+                     /*outputs=*/cmNinjaDeps(1, verifyStampFile),
+                     /*implicitOuts=*/cmNinjaDeps(),
+                     /*explicitDeps=*/cmNinjaDeps(),
+                     /*implicitDeps=*/verifyForceDeps,
+                     /*orderOnlyDeps=*/cmNinjaDeps(), variables);
+
+    variables.erase("restat");
+    implicitDeps.push_back(verifyScriptFile);
+    explicitDeps.push_back(verifyStampFile);
+  } else if (!this->SupportsManifestRestat() &&
+             cm->DoWriteGlobVerifyTarget()) {
+    std::ostringstream msg;
+    msg << "The detected version of Ninja:\n"
+        << "  " << this->NinjaVersion << "\n"
+        << "is less than the version of Ninja required by CMake for adding "
+           "restat dependencies to the build.ninja manifest regeneration "
+           "target:\n"
+        << "  " << this->RequiredNinjaVersionForManifestRestat() << "\n";
+    msg << "Any pre-check scripts, such as those generated for file(GLOB "
+           "CONFIGURE_DEPENDS), will not be run by Ninja.";
+    this->GetCMakeInstance()->IssueMessage(cmake::AUTHOR_WARNING, msg.str());
+  }
+
+  std::sort(implicitDeps.begin(), implicitDeps.end());
+  implicitDeps.erase(std::unique(implicitDeps.begin(), implicitDeps.end()),
+                     implicitDeps.end());
+
   std::string const ninjaBuildFile = this->NinjaOutputPath(NINJA_BUILD_FILE);
   this->WriteBuild(os, "Re-run CMake if any of its inputs changed.",
                    "RERUN_CMAKE",
                    /*outputs=*/cmNinjaDeps(1, ninjaBuildFile),
-                   /*implicitOuts=*/cmNinjaDeps(),
-                   /*explicitDeps=*/cmNinjaDeps(), implicitDeps,
+                   /*implicitOuts=*/cmNinjaDeps(), explicitDeps, implicitDeps,
                    /*orderOnlyDeps=*/cmNinjaDeps(), variables);
 
+  cmNinjaDeps missingInputs;
+  std::set_difference(std::make_move_iterator(implicitDeps.begin()),
+                      std::make_move_iterator(implicitDeps.end()),
+                      CustomCommandOutputs.begin(), CustomCommandOutputs.end(),
+                      std::back_inserter(missingInputs));
+
   this->WritePhonyBuild(os, "A missing CMake input file is not an error.",
-                        implicitDeps, cmNinjaDeps());
+                        missingInputs, cmNinjaDeps());
 }
 
 std::string cmGlobalNinjaGenerator::ninjaCmd() const
@@ -1408,6 +1466,11 @@ bool cmGlobalNinjaGenerator::SupportsImplicitOuts() const
   return this->NinjaSupportsImplicitOuts;
 }
 
+bool cmGlobalNinjaGenerator::SupportsManifestRestat() const
+{
+  return this->NinjaSupportsManifestRestat;
+}
+
 void cmGlobalNinjaGenerator::WriteTargetClean(std::ostream& os)
 {
   WriteRule(*this->RulesFileStream, "CLEAN", ninjaCmd() + " -t clean",
@@ -1758,7 +1821,7 @@ bool cmGlobalNinjaGenerator::WriteDyndepFile(
   Json::Value tm = Json::objectValue;
   for (cmFortranObjectInfo const& object : objects) {
     for (std::string const& p : object.Provides) {
-      std::string const mod = module_dir + p + ".mod";
+      std::string const mod = module_dir + p;
       mod_files[p] = mod;
       tm[p] = mod;
     }
diff --git a/Source/cmGlobalNinjaGenerator.h b/Source/cmGlobalNinjaGenerator.h
index 7f80d0806..00fa348c0 100644
--- a/Source/cmGlobalNinjaGenerator.h
+++ b/Source/cmGlobalNinjaGenerator.h
@@ -73,7 +73,6 @@ 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);
 
@@ -208,7 +207,8 @@ public:
                             const std::string& projectName,
                             const std::string& projectDir,
                             const std::string& targetName,
-                            const std::string& config, bool fast, bool verbose,
+                            const std::string& config, bool fast, int jobs,
+                            bool verbose,
                             std::vector<std::string> const& makeOptions =
                               std::vector<std::string>()) override;
 
@@ -346,8 +346,10 @@ public:
   static std::string RequiredNinjaVersion() { return "1.3"; }
   static std::string RequiredNinjaVersionForConsolePool() { return "1.5"; }
   static std::string RequiredNinjaVersionForImplicitOuts() { return "1.7"; }
+  static std::string RequiredNinjaVersionForManifestRestat() { return "1.8"; }
   bool SupportsConsolePool() const;
   bool SupportsImplicitOuts() const;
+  bool SupportsManifestRestat() const;
 
   std::string NinjaOutputPath(std::string const& path) const;
   bool HasOutputPathPrefix() const { return !this->OutputPathPrefix.empty(); }
@@ -460,6 +462,7 @@ private:
   std::string NinjaVersion;
   bool NinjaSupportsConsolePool;
   bool NinjaSupportsImplicitOuts;
+  bool NinjaSupportsManifestRestat;
   unsigned long NinjaSupportsDyndeps;
 
 private:
diff --git a/Source/cmGlobalUnixMakefileGenerator3.cxx b/Source/cmGlobalUnixMakefileGenerator3.cxx
index d990a6c02..61c42be4e 100644
--- a/Source/cmGlobalUnixMakefileGenerator3.cxx
+++ b/Source/cmGlobalUnixMakefileGenerator3.cxx
@@ -7,7 +7,6 @@
 #include <sstream>
 #include <utility>
 
-#include "cmAlgorithms.h"
 #include "cmDocumentationEntry.h"
 #include "cmGeneratedFileStream.h"
 #include "cmGeneratorTarget.h"
@@ -241,6 +240,10 @@ void cmGlobalUnixMakefileGenerator3::WriteMainMakefile2()
   lg->WriteMakeRule(makefileStream, "The main recursive preinstall target",
                     "preinstall", depends, no_commands, true);
 
+  // Write an empty clean:
+  lg->WriteMakeRule(makefileStream, "The main recursive clean target", "clean",
+                    depends, no_commands, true);
+
   // Write out the "special" stuff
   lg->WriteSpecialTargetsTop(makefileStream);
 
@@ -256,6 +259,10 @@ void cmGlobalUnixMakefileGenerator3::WriteMainMakefile2()
 
 void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
 {
+  if (this->GlobalSettingIsOn("CMAKE_SUPPRESS_REGENERATION")) {
+    return;
+  }
+
   // Open the output file.  This should not be copy-if-different
   // because the check-build-system step compares the makefile time to
   // see if the build system must be regenerated.
@@ -293,6 +300,13 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
     lfiles.insert(lfiles.end(), lg->GetMakefile()->GetListFiles().begin(),
                   lg->GetMakefile()->GetListFiles().end());
   }
+
+  cmake* cm = this->GetCMakeInstance();
+  if (cm->DoWriteGlobVerifyTarget()) {
+    lfiles.push_back(cm->GetGlobVerifyScript());
+    lfiles.push_back(cm->GetGlobVerifyStamp());
+  }
+
   // 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.
@@ -479,31 +493,33 @@ 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)
+  int jobs, bool /*verbose*/, std::vector<std::string> const& makeOptions)
 {
+  cmMakefile* mf;
+  if (!this->Makefiles.empty()) {
+    mf = this->Makefiles[0];
+  } else {
+    cmStateSnapshot snapshot = this->CMakeInstance->GetCurrentSnapshot();
+    snapshot.GetDirectory().SetCurrentSource(
+      this->CMakeInstance->GetHomeDirectory());
+    snapshot.GetDirectory().SetCurrentBinary(
+      this->CMakeInstance->GetHomeOutputDirectory());
+    snapshot.SetDefaultDefinitions();
+    mf = new cmMakefile(this, snapshot);
+  }
+
   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")) {
-    makeCommand.push_back("/NOLOGO");
+  if (jobs != cmake::NO_BUILD_PARALLEL_LEVEL) {
+    makeCommand.push_back("-j");
+    if (jobs != cmake::DEFAULT_BUILD_PARALLEL_LEVEL) {
+      makeCommand.push_back(std::to_string(jobs));
+    }
   }
+
   makeCommand.insert(makeCommand.end(), makeOptions.begin(),
                      makeOptions.end());
   if (!targetName.empty()) {
-    cmMakefile* mf;
-    if (!this->Makefiles.empty()) {
-      mf = this->Makefiles[0];
-    } else {
-      cmStateSnapshot snapshot = this->CMakeInstance->GetCurrentSnapshot();
-      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) {
       tname += "/fast";
@@ -513,9 +529,9 @@ void cmGlobalUnixMakefileGenerator3::GenerateBuildCommand(
       conv.ConvertToRelativePath(mf->GetState()->GetBinaryDirectory(), tname);
     cmSystemTools::ConvertToOutputSlashes(tname);
     makeCommand.push_back(std::move(tname));
-    if (this->Makefiles.empty()) {
-      delete mf;
-    }
+  }
+  if (this->Makefiles.empty()) {
+    delete mf;
   }
 }
 
@@ -525,7 +541,10 @@ void cmGlobalUnixMakefileGenerator3::WriteConvenienceRules(
   std::vector<std::string> depends;
   std::vector<std::string> commands;
 
-  depends.push_back("cmake_check_build_system");
+  bool regenerate = !this->GlobalSettingIsOn("CMAKE_SUPPRESS_REGENERATION");
+  if (regenerate) {
+    depends.push_back("cmake_check_build_system");
+  }
 
   // write the target convenience rules
   for (cmLocalGenerator* localGen : this->LocalGenerators) {
@@ -558,7 +577,9 @@ void cmGlobalUnixMakefileGenerator3::WriteConvenienceRules(
         tmp += "Makefile2";
         commands.push_back(lg->GetRecursiveMakeCall(tmp.c_str(), name));
         depends.clear();
-        depends.push_back("cmake_check_build_system");
+        if (regenerate) {
+          depends.push_back("cmake_check_build_system");
+        }
         lg->WriteMakeRule(ruleFileStream, "Build rule for target.", name,
                           depends, commands, true);
 
@@ -609,19 +630,23 @@ void cmGlobalUnixMakefileGenerator3::WriteConvenienceRules2(
   // write the directory level rules for this local gen
   this->WriteDirectoryRules2(ruleFileStream, lg);
 
-  depends.push_back("cmake_check_build_system");
+  bool regenerate = !this->GlobalSettingIsOn("CMAKE_SUPPRESS_REGENERATION");
+  if (regenerate) {
+    depends.push_back("cmake_check_build_system");
+  }
 
   // for each target Generate the rule files for each target.
   const std::vector<cmGeneratorTarget*>& targets = lg->GetGeneratorTargets();
   for (cmGeneratorTarget* gtarget : targets) {
     int type = gtarget->GetType();
     std::string name = gtarget->GetName();
-    if (!name.empty() && ((type == cmStateEnums::EXECUTABLE) ||
-                          (type == cmStateEnums::STATIC_LIBRARY) ||
-                          (type == cmStateEnums::SHARED_LIBRARY) ||
-                          (type == cmStateEnums::MODULE_LIBRARY) ||
-                          (type == cmStateEnums::OBJECT_LIBRARY) ||
-                          (type == cmStateEnums::UTILITY))) {
+    if (!name.empty() &&
+        ((type == cmStateEnums::EXECUTABLE) ||
+         (type == cmStateEnums::STATIC_LIBRARY) ||
+         (type == cmStateEnums::SHARED_LIBRARY) ||
+         (type == cmStateEnums::MODULE_LIBRARY) ||
+         (type == cmStateEnums::OBJECT_LIBRARY) ||
+         (type == cmStateEnums::UTILITY))) {
       std::string makefileName;
       // Add a rule to build the target by name.
       localName = lg->GetRelativeTargetDirectory(gtarget);
@@ -715,7 +740,9 @@ void cmGlobalUnixMakefileGenerator3::WriteConvenienceRules2(
         commands.push_back(progCmd.str());
       }
       depends.clear();
-      depends.push_back("cmake_check_build_system");
+      if (regenerate) {
+        depends.push_back("cmake_check_build_system");
+      }
       localName = lg->GetRelativeTargetDirectory(gtarget);
       localName += "/rule";
       lg->WriteMakeRule(ruleFileStream,
@@ -768,7 +795,7 @@ void cmGlobalUnixMakefileGenerator3::WriteConvenienceRules2(
   }
 }
 
-// Build a map that contains a the set of targets used by each local
+// Build a map that contains the set of targets used by each local
 // generator directory level.
 void cmGlobalUnixMakefileGenerator3::InitializeProgressMarks()
 {
@@ -894,11 +921,14 @@ void cmGlobalUnixMakefileGenerator3::WriteHelpRule(
   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,
+                 "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");
+  if (!this->GlobalSettingIsOn("CMAKE_SUPPRESS_REGENERATION")) {
+    lg->AppendEcho(commands, "... depend");
+  }
 
   // Keep track of targets already listed.
   std::set<std::string> emittedTargets;
diff --git a/Source/cmGlobalUnixMakefileGenerator3.h b/Source/cmGlobalUnixMakefileGenerator3.h
index f9ce88cb4..a2ad09516 100644
--- a/Source/cmGlobalUnixMakefileGenerator3.h
+++ b/Source/cmGlobalUnixMakefileGenerator3.h
@@ -132,7 +132,8 @@ public:
                             const std::string& projectName,
                             const std::string& projectDir,
                             const std::string& targetName,
-                            const std::string& config, bool fast, bool verbose,
+                            const std::string& config, bool fast, int jobs,
+                            bool verbose,
                             std::vector<std::string> const& makeOptions =
                               std::vector<std::string>()) override;
 
diff --git a/Source/cmGlobalVisualStudio10Generator.cxx b/Source/cmGlobalVisualStudio10Generator.cxx
index 73a5daec2..a5709d58d 100644
--- a/Source/cmGlobalVisualStudio10Generator.cxx
+++ b/Source/cmGlobalVisualStudio10Generator.cxx
@@ -231,9 +231,73 @@ bool cmGlobalVisualStudio10Generator::SetGeneratorToolset(
     }
   }
 
+  if (!this->GeneratorToolsetVersion.empty() &&
+      this->GeneratorToolsetVersion != "Test Toolset Version") {
+    // If a specific minor version of the toolset was requested, verify that it
+    // is compatible to the major version and that is exists on disk.
+    // If not clear the value.
+    std::string version = this->GeneratorToolsetVersion;
+    cmsys::RegularExpression regex("[0-9][0-9]\\.[0-9][0-9]");
+    if (regex.find(version)) {
+      version = "v" + version.erase(2, 1);
+    } else {
+      // Version not recognized. Clear it.
+      version.clear();
+    }
+
+    if (version.find(this->GetPlatformToolsetString()) != 0) {
+      std::ostringstream e;
+      /* clang-format off */
+      e <<
+        "Generator\n"
+        "  " << this->GetName() << "\n"
+        "given toolset and version specification\n"
+        "  " << this->GetPlatformToolsetString() << ",version=" <<
+        this->GeneratorToolsetVersion << "\n"
+        "contains an invalid version specification."
+      ;
+      /* clang-format on */
+      mf->IssueMessage(cmake::FATAL_ERROR, e.str());
+
+      // Clear the configured tool-set
+      this->GeneratorToolsetVersion.clear();
+    }
+
+    bool const isDefaultToolset =
+      this->IsDefaultToolset(this->GeneratorToolsetVersion);
+    if (isDefaultToolset) {
+      // If the given version is the default toolset, remove the setting
+      this->GeneratorToolsetVersion.clear();
+    } else {
+      std::string const toolsetPath = this->GetAuxiliaryToolset();
+      if (!toolsetPath.empty() && !cmSystemTools::FileExists(toolsetPath)) {
+
+        std::ostringstream e;
+        /* clang-format off */
+        e <<
+          "Generator\n"
+          "  " << this->GetName() << "\n"
+          "given toolset and version specification\n"
+          "  " << this->GetPlatformToolsetString() << ",version=" <<
+          this->GeneratorToolsetVersion << "\n"
+          "does not seem to be installed at\n" <<
+          "  " << toolsetPath;
+        ;
+        /* clang-format on */
+        mf->IssueMessage(cmake::FATAL_ERROR, e.str());
+
+        // Clear the configured tool-set
+        this->GeneratorToolsetVersion.clear();
+      }
+    }
+  }
+
   if (const char* toolset = this->GetPlatformToolset()) {
     mf->AddDefinition("CMAKE_VS_PLATFORM_TOOLSET", toolset);
   }
+  if (const char* version = this->GetPlatformToolsetVersion()) {
+    mf->AddDefinition("CMAKE_VS_PLATFORM_TOOLSET_VERSION", version);
+  }
   if (const char* hostArch = this->GetPlatformToolsetHostArchitecture()) {
     mf->AddDefinition("CMAKE_VS_PLATFORM_TOOLSET_HOST_ARCHITECTURE", hostArch);
   }
@@ -319,6 +383,10 @@ bool cmGlobalVisualStudio10Generator::ProcessGeneratorToolsetField(
     this->GeneratorToolsetCuda = value;
     return true;
   }
+  if (key == "version") {
+    this->GeneratorToolsetVersion = value;
+    return true;
+  }
   return false;
 }
 
@@ -512,6 +580,25 @@ std::string const& cmGlobalVisualStudio10Generator::GetPlatformToolsetString()
   return empty;
 }
 
+const char* cmGlobalVisualStudio10Generator::GetPlatformToolsetVersion() const
+{
+  std::string const& version = this->GetPlatformToolsetVersionString();
+  if (version.empty()) {
+    return nullptr;
+  }
+  return version.c_str();
+}
+
+std::string const&
+cmGlobalVisualStudio10Generator::GetPlatformToolsetVersionString() const
+{
+  if (!this->GeneratorToolsetVersion.empty()) {
+    return this->GeneratorToolsetVersion;
+  }
+  static std::string const empty;
+  return empty;
+}
+
 const char*
 cmGlobalVisualStudio10Generator::GetPlatformToolsetHostArchitecture() const
 {
@@ -535,6 +622,17 @@ cmGlobalVisualStudio10Generator::GetPlatformToolsetCudaString() const
   return this->GeneratorToolsetCuda;
 }
 
+bool cmGlobalVisualStudio10Generator::IsDefaultToolset(
+  const std::string&) const
+{
+  return true;
+}
+
+std::string cmGlobalVisualStudio10Generator::GetAuxiliaryToolset() const
+{
+  return {};
+}
+
 bool cmGlobalVisualStudio10Generator::FindMakeProgram(cmMakefile* mf)
 {
   if (!this->cmGlobalVisualStudio8Generator::FindMakeProgram(mf)) {
@@ -636,126 +734,89 @@ bool cmGlobalVisualStudio10Generator::FindVCTargetsPath(cmMakefile* mf)
     cmsys::ofstream fout(vcxprojAbs.c_str());
     cmXMLWriter xw(fout);
 
-    /* clang-format off */
-    xw.StartDocument();
-    xw.StartElement("Project");
-     xw.Attribute("DefaultTargets", "Build");
-     xw.Attribute("ToolsVersion", "4.0");
-     xw.Attribute("xmlns",
-                  "http://schemas.microsoft.com/developer/msbuild/2003");
-     if (this->IsNsightTegra()) {
-       xw.StartElement("PropertyGroup");
-        xw.Attribute("Label", "NsightTegraProject");
-        xw.StartElement("NsightTegraProjectRevisionNumber");
-         xw.Content("6");
-        xw.EndElement(); // NsightTegraProjectRevisionNumber
-       xw.EndElement(); // PropertyGroup
-     }
-     xw.StartElement("ItemGroup");
-      xw.Attribute("Label", "ProjectConfigurations");
-      xw.StartElement("ProjectConfiguration");
-       xw.Attribute("Include", "Debug|" + this->GetPlatformName());
-       xw.StartElement("Configuration");
-        xw.Content("Debug");
-       xw.EndElement(); // Configuration
-       xw.StartElement("Platform");
-        xw.Content(this->GetPlatformName());
-       xw.EndElement(); // Platform
-      xw.EndElement(); // ProjectConfiguration
-     xw.EndElement(); // ItemGroup
-    xw.StartElement("PropertyGroup");
-     xw.Attribute("Label", "Globals");
-     xw.StartElement("ProjectGuid");
-      xw.Content("{F3FC6D86-508D-3FB1-96D2-995F08B142EC}");
-     xw.EndElement(); // ProjectGuid
-     xw.StartElement("Keyword");
-      xw.Content("Win32Proj");
-     xw.EndElement(); // Keyword
-     xw.StartElement("Platform");
-      xw.Content(this->GetPlatformName());
-     xw.EndElement(); // Platform
-     if (this->GetSystemName() == "WindowsPhone") {
-       xw.StartElement("ApplicationType");
-        xw.Content("Windows Phone");
-       xw.EndElement(); // ApplicationType
-       xw.StartElement("ApplicationTypeRevision");
-        xw.Content(this->GetSystemVersion());
-       xw.EndElement(); // ApplicationTypeRevision
-     } else if (this->GetSystemName() == "WindowsStore") {
-       xw.StartElement("ApplicationType");
-        xw.Content("Windows Store");
-       xw.EndElement(); // ApplicationType
-       xw.StartElement("ApplicationTypeRevision");
-        xw.Content(this->GetSystemVersion());
-       xw.EndElement(); // ApplicationTypeRevision
-     }
-     if (!this->WindowsTargetPlatformVersion.empty()) {
-       xw.StartElement("WindowsTargetPlatformVersion");
-        xw.Content(this->WindowsTargetPlatformVersion);
-       xw.EndElement(); // WindowsTargetPlatformVersion
-     }
-     if (this->GetPlatformName() == "ARM64") {
-       xw.StartElement("WindowsSDKDesktopARM64Support");
-        xw.Content("true");
-       xw.EndElement(); // WindowsSDK64DesktopARMSupport
-     }
-     else if (this->GetPlatformName() == "ARM") {
-       xw.StartElement("WindowsSDKDesktopARMSupport");
-        xw.Content("true");
-       xw.EndElement(); // WindowsSDKDesktopARMSupport
-     }
-    xw.EndElement(); // PropertyGroup
-    xw.StartElement("Import");
-     xw.Attribute("Project",
-                  "$(VCTargetsPath)\\Microsoft.Cpp.Default.props");
-    xw.EndElement(); // Import
+    cmXMLDocument doc(xw);
+    cmXMLElement eprj(doc, "Project");
+    eprj.Attribute("DefaultTargets", "Build");
+    eprj.Attribute("ToolsVersion", "4.0");
+    eprj.Attribute("xmlns",
+                   "http://schemas.microsoft.com/developer/msbuild/2003");
+    if (this->IsNsightTegra()) {
+      cmXMLElement epg(eprj, "PropertyGroup");
+      epg.Attribute("Label", "NsightTegraProject");
+      cmXMLElement(epg, "NsightTegraProjectRevisionNumber").Content("6");
+    }
+    {
+      cmXMLElement eig(eprj, "ItemGroup");
+      eig.Attribute("Label", "ProjectConfigurations");
+      cmXMLElement epc(eig, "ProjectConfiguration");
+      epc.Attribute("Include", "Debug|" + this->GetPlatformName());
+      cmXMLElement(epc, "Configuration").Content("Debug");
+      cmXMLElement(epc, "Platform").Content(this->GetPlatformName());
+    }
+    {
+      cmXMLElement epg(eprj, "PropertyGroup");
+      epg.Attribute("Label", "Globals");
+      cmXMLElement(epg, "ProjectGuid")
+        .Content("{F3FC6D86-508D-3FB1-96D2-995F08B142EC}");
+      cmXMLElement(epg, "Keyword").Content("Win32Proj");
+      cmXMLElement(epg, "Platform").Content(this->GetPlatformName());
+      if (this->GetSystemName() == "WindowsPhone") {
+        cmXMLElement(epg, "ApplicationType").Content("Windows Phone");
+        cmXMLElement(epg, "ApplicationTypeRevision")
+          .Content(this->GetSystemVersion());
+      } else if (this->GetSystemName() == "WindowsStore") {
+        cmXMLElement(epg, "ApplicationType").Content("Windows Store");
+        cmXMLElement(epg, "ApplicationTypeRevision")
+          .Content(this->GetSystemVersion());
+      }
+      if (!this->WindowsTargetPlatformVersion.empty()) {
+        cmXMLElement(epg, "WindowsTargetPlatformVersion")
+          .Content(this->WindowsTargetPlatformVersion);
+      }
+      if (this->GetPlatformName() == "ARM64") {
+        cmXMLElement(epg, "WindowsSDKDesktopARM64Support").Content("true");
+      } else if (this->GetPlatformName() == "ARM") {
+        cmXMLElement(epg, "WindowsSDKDesktopARMSupport").Content("true");
+      }
+    }
+    cmXMLElement(eprj, "Import")
+      .Attribute("Project", "$(VCTargetsPath)\\Microsoft.Cpp.Default.props");
     if (!this->GeneratorToolsetHostArchitecture.empty()) {
-      xw.StartElement("PropertyGroup");
-       xw.StartElement("PreferredToolArchitecture");
-        xw.Content(this->GeneratorToolsetHostArchitecture);
-       xw.EndElement(); // PreferredToolArchitecture
-      xw.EndElement(); // PropertyGroup
+      cmXMLElement epg(eprj, "PropertyGroup");
+      cmXMLElement(epg, "PreferredToolArchitecture")
+        .Content(this->GeneratorToolsetHostArchitecture);
     }
-    xw.StartElement("PropertyGroup");
-     xw.Attribute("Label", "Configuration");
-     xw.StartElement("ConfigurationType");
+    {
+      cmXMLElement epg(eprj, "PropertyGroup");
+      epg.Attribute("Label", "Configuration");
+      {
+        cmXMLElement ect(epg, "ConfigurationType");
+        if (this->IsNsightTegra()) {
+          // Tegra-Android platform does not understand "Utility".
+          ect.Content("StaticLibrary");
+        } else {
+          ect.Content("Utility");
+        }
+      }
+      cmXMLElement(epg, "CharacterSet").Content("MultiByte");
       if (this->IsNsightTegra()) {
-        // Tegra-Android platform does not understand "Utility".
-        xw.Content("StaticLibrary");
+        cmXMLElement(epg, "NdkToolchainVersion")
+          .Content(this->GetPlatformToolsetString());
       } else {
-        xw.Content("Utility");
+        cmXMLElement(epg, "PlatformToolset")
+          .Content(this->GetPlatformToolsetString());
       }
-     xw.EndElement(); // ConfigurationType
-     xw.StartElement("CharacterSet");
-      xw.Content("MultiByte");
-     xw.EndElement(); // CharacterSet
-     if (this->IsNsightTegra()) {
-       xw.StartElement("NdkToolchainVersion");
-       xw.Content(this->GetPlatformToolsetString());
-       xw.EndElement(); // NdkToolchainVersion
-     } else {
-       xw.StartElement("PlatformToolset");
-       xw.Content(this->GetPlatformToolsetString());
-       xw.EndElement(); // PlatformToolset
-     }
-    xw.EndElement(); // PropertyGroup
-    xw.StartElement("Import");
-     xw.Attribute("Project", "$(VCTargetsPath)\\Microsoft.Cpp.props");
-    xw.EndElement(); // Import
-    xw.StartElement("ItemDefinitionGroup");
-     xw.StartElement("PostBuildEvent");
-      xw.StartElement("Command");
-       xw.Content("echo VCTargetsPath=$(VCTargetsPath)");
-      xw.EndElement(); // Command
-     xw.EndElement(); // PostBuildEvent
-    xw.EndElement(); // ItemDefinitionGroup
-    xw.StartElement("Import");
-     xw.Attribute("Project",
-                  "$(VCTargetsPath)\\Microsoft.Cpp.targets");
-    xw.EndElement(); // Import
-    xw.EndElement(); // Project
-    xw.EndDocument();
-    /* clang-format on */
+    }
+    cmXMLElement(eprj, "Import")
+      .Attribute("Project", "$(VCTargetsPath)\\Microsoft.Cpp.props");
+    {
+      cmXMLElement eidg(eprj, "ItemDefinitionGroup");
+      cmXMLElement epbe(eidg, "PostBuildEvent");
+      cmXMLElement(epbe, "Command")
+        .Content("echo VCTargetsPath=$(VCTargetsPath)");
+    }
+    cmXMLElement(eprj, "Import")
+      .Attribute("Project", "$(VCTargetsPath)\\Microsoft.Cpp.targets");
   }
 
   std::vector<std::string> cmd;
@@ -801,7 +862,7 @@ 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)
+  int jobs, bool verbose, std::vector<std::string> const& makeOptions)
 {
   // Select the caller- or user-preferred make program, else MSBuild.
   std::string makeProgramSelected =
@@ -842,7 +903,7 @@ void cmGlobalVisualStudio10Generator::GenerateBuildCommand(
     // Use devenv to build solutions containing Intel Fortran projects.
     cmGlobalVisualStudio7Generator::GenerateBuildCommand(
       makeCommand, makeProgram, projectName, projectDir, targetName, config,
-      fast, verbose, makeOptions);
+      fast, jobs, verbose, makeOptions);
     return;
   }
 
@@ -850,6 +911,7 @@ void cmGlobalVisualStudio10Generator::GenerateBuildCommand(
 
   std::string realTarget = targetName;
   // msbuild.exe CxxOnly.sln /t:Build /p:Configuration=Debug /target:ALL_BUILD
+  //                         /m
   if (realTarget.empty()) {
     realTarget = "ALL_BUILD";
   }
@@ -878,6 +940,17 @@ void cmGlobalVisualStudio10Generator::GenerateBuildCommand(
   makeCommand.push_back(configArg);
   makeCommand.push_back(std::string("/p:VisualStudioVersion=") +
                         this->GetIDEVersion());
+
+  if (jobs != cmake::NO_BUILD_PARALLEL_LEVEL) {
+    if (jobs == cmake::DEFAULT_BUILD_PARALLEL_LEVEL) {
+      makeCommand.push_back("/m");
+    } else {
+      makeCommand.push_back(std::string("/m:") + std::to_string(jobs));
+    }
+    // Having msbuild.exe and cl.exe using multiple jobs is discouraged
+    makeCommand.push_back("/p:CL_MPCount=1");
+  }
+
   makeCommand.insert(makeCommand.end(), makeOptions.begin(),
                      makeOptions.end());
 }
diff --git a/Source/cmGlobalVisualStudio10Generator.h b/Source/cmGlobalVisualStudio10Generator.h
index f2501c222..6eb597c9a 100644
--- a/Source/cmGlobalVisualStudio10Generator.h
+++ b/Source/cmGlobalVisualStudio10Generator.h
@@ -29,7 +29,8 @@ public:
                             const std::string& projectName,
                             const std::string& projectDir,
                             const std::string& targetName,
-                            const std::string& config, bool fast, bool verbose,
+                            const std::string& config, bool fast, int jobs,
+                            bool verbose,
                             std::vector<std::string> const& makeOptions =
                               std::vector<std::string>()) override;
 
@@ -54,6 +55,10 @@ public:
   const char* GetPlatformToolset() const;
   std::string const& GetPlatformToolsetString() const;
 
+  /** The toolset version.  */
+  const char* GetPlatformToolsetVersion() const;
+  std::string const& GetPlatformToolsetVersionString() const;
+
   /** The toolset host architecture name (e.g. x64 for 64-bit host tools).  */
   const char* GetPlatformToolsetHostArchitecture() const;
 
@@ -101,6 +106,9 @@ public:
   std::string Encoding() override;
   virtual const char* GetToolsVersion() { return "4.0"; }
 
+  virtual bool IsDefaultToolset(const std::string& version) const;
+  virtual std::string GetAuxiliaryToolset() const;
+
   bool FindMakeProgram(cmMakefile* mf) override;
 
   static std::string GetInstalledNsightTegraVersion();
@@ -135,6 +143,7 @@ protected:
   std::string const& GetMSBuildCommand();
 
   std::string GeneratorToolset;
+  std::string GeneratorToolsetVersion;
   std::string GeneratorToolsetHostArchitecture;
   std::string GeneratorToolsetCuda;
   std::string DefaultPlatformToolset;
diff --git a/Source/cmGlobalVisualStudio12Generator.cxx b/Source/cmGlobalVisualStudio12Generator.cxx
index a9c605cad..e05ae70dc 100644
--- a/Source/cmGlobalVisualStudio12Generator.cxx
+++ b/Source/cmGlobalVisualStudio12Generator.cxx
@@ -125,8 +125,9 @@ bool cmGlobalVisualStudio12Generator::InitializeWindowsPhone(cmMakefile* mf)
   if (!this->SelectWindowsPhoneToolset(this->DefaultPlatformToolset)) {
     std::ostringstream e;
     if (this->DefaultPlatformToolset.empty()) {
-      e << this->GetName() << " supports Windows Phone '8.0' and '8.1', but "
-                              "not '"
+      e << this->GetName()
+        << " supports Windows Phone '8.0' and '8.1', but "
+           "not '"
         << this->SystemVersion << "'.  Check CMAKE_SYSTEM_VERSION.";
     } else {
       e << "A Windows Phone component with CMake requires both the Windows "
@@ -144,8 +145,9 @@ bool cmGlobalVisualStudio12Generator::InitializeWindowsStore(cmMakefile* mf)
   if (!this->SelectWindowsStoreToolset(this->DefaultPlatformToolset)) {
     std::ostringstream e;
     if (this->DefaultPlatformToolset.empty()) {
-      e << this->GetName() << " supports Windows Store '8.0' and '8.1', but "
-                              "not '"
+      e << this->GetName()
+        << " supports Windows Store '8.0' and '8.1', but "
+           "not '"
         << this->SystemVersion << "'.  Check CMAKE_SYSTEM_VERSION.";
     } else {
       e << "A Windows Store component with CMake requires both the Windows "
diff --git a/Source/cmGlobalVisualStudio12Generator.h b/Source/cmGlobalVisualStudio12Generator.h
index c941809ff..9d6554a34 100644
--- a/Source/cmGlobalVisualStudio12Generator.h
+++ b/Source/cmGlobalVisualStudio12Generator.h
@@ -30,6 +30,7 @@ public:
   // from the .Net Framework version and instead made it have it's own
   // version number
   const char* GetToolsVersion() override { return "12.0"; }
+
 protected:
   bool ProcessGeneratorToolsetField(std::string const& key,
                                     std::string const& value) override;
@@ -48,6 +49,7 @@ protected:
   bool IsWindowsPhoneToolsetInstalled() const;
   bool IsWindowsStoreToolsetInstalled() const;
   const char* GetIDEVersion() override { return "12.0"; }
+
 private:
   class Factory;
 };
diff --git a/Source/cmGlobalVisualStudio14Generator.cxx b/Source/cmGlobalVisualStudio14Generator.cxx
index c440e0de6..b0db1467b 100644
--- a/Source/cmGlobalVisualStudio14Generator.cxx
+++ b/Source/cmGlobalVisualStudio14Generator.cxx
@@ -122,8 +122,9 @@ bool cmGlobalVisualStudio14Generator::InitializeWindowsStore(cmMakefile* mf)
   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 '"
+      e << this->GetName()
+        << " supports Windows Store '8.0', '8.1' and "
+           "'10.0', but not '"
         << this->SystemVersion << "'.  Check CMAKE_SYSTEM_VERSION.";
     } else {
       e << "A Windows Store component with CMake requires both the Windows "
diff --git a/Source/cmGlobalVisualStudio14Generator.h b/Source/cmGlobalVisualStudio14Generator.h
index d92a11a18..4868df02e 100644
--- a/Source/cmGlobalVisualStudio14Generator.h
+++ b/Source/cmGlobalVisualStudio14Generator.h
@@ -27,6 +27,7 @@ public:
   void WriteSLNHeader(std::ostream& fout) override;
 
   const char* GetToolsVersion() override { return "14.0"; }
+
 protected:
   bool InitializeWindows(cmMakefile* mf) override;
   bool InitializeWindowsStore(cmMakefile* mf) override;
diff --git a/Source/cmGlobalVisualStudio15Generator.cxx b/Source/cmGlobalVisualStudio15Generator.cxx
index 014d93d94..9983a43de 100644
--- a/Source/cmGlobalVisualStudio15Generator.cxx
+++ b/Source/cmGlobalVisualStudio15Generator.cxx
@@ -158,6 +158,46 @@ bool cmGlobalVisualStudio15Generator::GetVSInstance(std::string& dir) const
   return vsSetupAPIHelper.GetVSInstanceInfo(dir);
 }
 
+bool cmGlobalVisualStudio15Generator::IsDefaultToolset(
+  const std::string& version) const
+{
+  if (version.empty()) {
+    return true;
+  }
+
+  std::string vcToolsetVersion;
+  if (this->vsSetupAPIHelper.GetVCToolsetVersion(vcToolsetVersion)) {
+
+    cmsys::RegularExpression regex("[0-9][0-9]\\.[0-9]+");
+    if (regex.find(version) && regex.find(vcToolsetVersion)) {
+      const auto majorMinorEnd = vcToolsetVersion.find('.', 3);
+      const auto majorMinor = vcToolsetVersion.substr(0, majorMinorEnd);
+      return version == majorMinor;
+    }
+  }
+
+  return false;
+}
+
+std::string cmGlobalVisualStudio15Generator::GetAuxiliaryToolset() const
+{
+  const char* version = this->GetPlatformToolsetVersion();
+  if (version) {
+    std::string instancePath;
+    GetVSInstance(instancePath);
+    std::stringstream path;
+    path << instancePath;
+    path << "/VC/Auxiliary/Build/";
+    path << version;
+    path << "/Microsoft.VCToolsVersion." << version << ".props";
+
+    std::string toolsetPath = path.str();
+    cmSystemTools::ConvertToUnixSlashes(toolsetPath);
+    return toolsetPath;
+  }
+  return {};
+}
+
 bool cmGlobalVisualStudio15Generator::InitializeWindows(cmMakefile* mf)
 {
   // If the Win 8.1 SDK is installed then we can select a SDK matching
diff --git a/Source/cmGlobalVisualStudio15Generator.h b/Source/cmGlobalVisualStudio15Generator.h
index 4f4e0b97b..cdc97ad9e 100644
--- a/Source/cmGlobalVisualStudio15Generator.h
+++ b/Source/cmGlobalVisualStudio15Generator.h
@@ -32,6 +32,9 @@ public:
 
   bool GetVSInstance(std::string& dir) const;
 
+  bool IsDefaultToolset(const std::string& version) const override;
+  std::string GetAuxiliaryToolset() const override;
+
 protected:
   bool InitializeWindows(cmMakefile* mf) override;
   bool SelectWindowsStoreToolset(std::string& toolset) const override;
diff --git a/Source/cmGlobalVisualStudio71Generator.cxx b/Source/cmGlobalVisualStudio71Generator.cxx
index 45cc5834c..0b086b064 100644
--- a/Source/cmGlobalVisualStudio71Generator.cxx
+++ b/Source/cmGlobalVisualStudio71Generator.cxx
@@ -98,7 +98,7 @@ void cmGlobalVisualStudio71Generator::WriteProject(std::ostream& fout,
     ext = ".vfproj";
     project = "Project(\"{6989167D-11E4-40FE-8C1A-2192A86A7E90}\") = \"";
   }
-  if (this->TargetIsCSharpOnly(t)) {
+  if (t->HasLanguage("CSharp", "")) {
     ext = ".csproj";
     project = "Project(\"{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}\") = \"";
   }
diff --git a/Source/cmGlobalVisualStudio7Generator.cxx b/Source/cmGlobalVisualStudio7Generator.cxx
index c915dc5eb..158f48431 100644
--- a/Source/cmGlobalVisualStudio7Generator.cxx
+++ b/Source/cmGlobalVisualStudio7Generator.cxx
@@ -199,7 +199,7 @@ 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)
+  int /*jobs*/, bool /*verbose*/, std::vector<std::string> const& makeOptions)
 {
   // Select the caller- or user-preferred make program, else devenv.
   std::string makeProgramSelected =
@@ -294,19 +294,6 @@ void cmGlobalVisualStudio7Generator::Generate()
   if (!cmSystemTools::GetErrorOccuredFlag()) {
     this->CallVisualStudioMacro(MacroReload);
   }
-
-  if (this->Version == VS8 && !this->CMakeInstance->GetIsInTryCompile()) {
-    const char* cmakeWarnVS8 =
-      this->CMakeInstance->GetState()->GetCacheEntryValue("CMAKE_WARN_VS8");
-    if (!cmakeWarnVS8 || !cmSystemTools::IsOff(cmakeWarnVS8)) {
-      this->CMakeInstance->IssueMessage(
-        cmake::WARNING,
-        "The \"Visual Studio 8 2005\" generator is deprecated "
-        "and will be removed in a future version of CMake."
-        "\n"
-        "Add CMAKE_WARN_VS8=OFF to the cache to disable this warning.");
-    }
-  }
 }
 
 void cmGlobalVisualStudio7Generator::OutputSLNFile(
diff --git a/Source/cmGlobalVisualStudio7Generator.h b/Source/cmGlobalVisualStudio7Generator.h
index 8d1bdc0cc..0c9dd889b 100644
--- a/Source/cmGlobalVisualStudio7Generator.h
+++ b/Source/cmGlobalVisualStudio7Generator.h
@@ -60,7 +60,8 @@ public:
                             const std::string& projectName,
                             const std::string& projectDir,
                             const std::string& targetName,
-                            const std::string& config, bool fast, bool verbose,
+                            const std::string& config, bool fast, int jobs,
+                            bool verbose,
                             std::vector<std::string> const& makeOptions =
                               std::vector<std::string>()) override;
 
diff --git a/Source/cmGlobalVisualStudio8Generator.cxx b/Source/cmGlobalVisualStudio8Generator.cxx
index ab8ad7022..117d05175 100644
--- a/Source/cmGlobalVisualStudio8Generator.cxx
+++ b/Source/cmGlobalVisualStudio8Generator.cxx
@@ -11,75 +11,6 @@
 #include "cmVisualStudioWCEPlatformParser.h"
 #include "cmake.h"
 
-static const char vs8generatorName[] = "Visual Studio 8 2005";
-
-class cmGlobalVisualStudio8Generator::Factory : public cmGlobalGeneratorFactory
-{
-public:
-  cmGlobalGenerator* CreateGlobalGenerator(const std::string& name,
-                                           cmake* cm) const override
-  {
-    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') {
-      return new cmGlobalVisualStudio8Generator(cm, name, "");
-    }
-
-    if (p[0] != ' ') {
-      return 0;
-    }
-
-    ++p;
-
-    if (!strcmp(p, "Win64")) {
-      return new cmGlobalVisualStudio8Generator(cm, name, "x64");
-    }
-
-    cmVisualStudioWCEPlatformParser parser(p);
-    parser.ParseVersion("8.0");
-    if (!parser.Found()) {
-      return 0;
-    }
-
-    cmGlobalVisualStudio8Generator* ret =
-      new cmGlobalVisualStudio8Generator(cm, name, p);
-    ret->WindowsCEVersion = parser.GetOSVersion();
-    return ret;
-  }
-
-  void GetDocumentation(cmDocumentationEntry& entry) const override
-  {
-    entry.Name = std::string(vs8generatorName) + " [arch]";
-    entry.Brief = "Deprecated.  Generates Visual Studio 2005 project files.  "
-                  "Optional [arch] can be \"Win64\".";
-  }
-
-  void GetGenerators(std::vector<std::string>& names) const override
-  {
-    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::string const& i : availablePlatforms) {
-      names.push_back("Visual Studio 8 2005 " + i);
-    }
-  }
-
-  bool SupportsToolset() const override { return false; }
-  bool SupportsPlatform() const override { return true; }
-};
-
-cmGlobalGeneratorFactory* cmGlobalVisualStudio8Generator::NewFactory()
-{
-  return new Factory;
-}
-
 cmGlobalVisualStudio8Generator::cmGlobalVisualStudio8Generator(
   cmake* cm, const std::string& name, const std::string& platformName)
   : cmGlobalVisualStudio71Generator(cm, platformName)
@@ -87,12 +18,6 @@ cmGlobalVisualStudio8Generator::cmGlobalVisualStudio8Generator(
   this->ProjectConfigurationSectionName = "ProjectConfigurationPlatforms";
   this->Name = name;
   this->ExtraFlagTable = this->GetExtraFlagTableVS8();
-  this->Version = VS8;
-  std::string vc8Express;
-  this->ExpressEdition = cmSystemTools::ReadRegistryValue(
-    "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VCExpress\\8.0\\Setup\\VC;"
-    "ProductDir",
-    vc8Express, cmSystemTools::KeyWOW64_32);
 }
 
 std::string cmGlobalVisualStudio8Generator::FindDevEnvCommand()
@@ -143,13 +68,6 @@ bool cmGlobalVisualStudio8Generator::SetGeneratorPlatform(std::string const& p,
   }
 }
 
-// output standard header for dsw file
-void cmGlobalVisualStudio8Generator::WriteSLNHeader(std::ostream& fout)
-{
-  fout << "Microsoft Visual Studio Solution File, Format Version 9.00\n";
-  fout << "# Visual Studio 2005\n";
-}
-
 std::string cmGlobalVisualStudio8Generator::GetGenerateStampList()
 {
   return "generate.stamp.list";
@@ -165,62 +83,22 @@ bool cmGlobalVisualStudio8Generator::UseFolderProperty()
   return IsExpressEdition() ? false : cmGlobalGenerator::UseFolderProperty();
 }
 
-std::string cmGlobalVisualStudio8Generator::GetUserMacrosDirectory()
-{
-  // Some VS8 sp0 versions cannot run macros.
-  // See http://support.microsoft.com/kb/928209
-  const char* vc8sp1Registry =
-    "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\8.0\\"
-    "InstalledProducts\\KB926601;";
-  const char* vc8exSP1Registry =
-    "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\8.0\\"
-    "InstalledProducts\\KB926748;";
-  std::string vc8sp1;
-  if (!cmSystemTools::ReadRegistryValue(vc8sp1Registry, 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)) {
-    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
-  return path;
-}
-
-std::string cmGlobalVisualStudio8Generator::GetUserMacrosRegKeyBase()
-{
-  return "Software\\Microsoft\\VisualStudio\\8.0\\vsmacros";
-}
-
 bool cmGlobalVisualStudio8Generator::AddCheckTarget()
 {
   // Add a special target on which all other targets depend that
   // checks the build system and optionally re-runs CMake.
-  const char* no_working_directory = 0;
+  // Skip the target if no regeneration is to be done.
+  if (this->GlobalSettingIsOn("CMAKE_SUPPRESS_REGENERATION")) {
+    return false;
+  }
+
+  const char* no_working_directory = nullptr;
   std::vector<std::string> no_depends;
   std::vector<cmLocalGenerator*> const& generators = this->LocalGenerators;
   cmLocalVisualStudio7Generator* lg =
     static_cast<cmLocalVisualStudio7Generator*>(generators[0]);
   cmMakefile* mf = lg->GetMakefile();
 
-  // Skip the target if no regeneration is to be done.
-  if (mf->IsOn("CMAKE_SUPPRESS_REGENERATION")) {
-    return false;
-  }
-
   cmCustomCommandLines noCommandLines;
   cmTarget* tgt = mf->AddUtilityCommand(
     CMAKE_CHECK_BUILD_SYSTEM_TARGET, cmMakefile::TargetOrigin::Generator,
@@ -266,6 +144,30 @@ bool cmGlobalVisualStudio8Generator::AddCheckTarget()
       listFiles.insert(listFiles.end(), lmf->GetListFiles().begin(),
                        lmf->GetListFiles().end());
     }
+
+    // Add a custom prebuild target to run the VerifyGlobs script.
+    cmake* cm = this->GetCMakeInstance();
+    if (cm->DoWriteGlobVerifyTarget()) {
+      cmCustomCommandLine verifyCommandLine;
+      verifyCommandLine.push_back(cmSystemTools::GetCMakeCommand());
+      verifyCommandLine.push_back("-P");
+      verifyCommandLine.push_back(cm->GetGlobVerifyScript());
+      cmCustomCommandLines verifyCommandLines;
+      verifyCommandLines.push_back(verifyCommandLine);
+      std::vector<std::string> byproducts;
+      byproducts.push_back(cm->GetGlobVerifyStamp());
+
+      mf->AddCustomCommandToTarget(CMAKE_CHECK_BUILD_SYSTEM_TARGET, byproducts,
+                                   no_depends, verifyCommandLines,
+                                   cmTarget::PRE_BUILD, "Checking File Globs",
+                                   no_working_directory, false);
+
+      // Ensure ZERO_CHECK always runs in Visual Studio using MSBuild,
+      // otherwise the prebuild command will not be run.
+      tgt->SetProperty("VS_GLOBAL_DisableFastUpToDateCheck", "true");
+      listFiles.push_back(cm->GetGlobVerifyStamp());
+    }
+
     // 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 =
@@ -273,8 +175,6 @@ bool cmGlobalVisualStudio8Generator::AddCheckTarget()
     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";
diff --git a/Source/cmGlobalVisualStudio8Generator.h b/Source/cmGlobalVisualStudio8Generator.h
index af83e4f1b..6f64b9c66 100644
--- a/Source/cmGlobalVisualStudio8Generator.h
+++ b/Source/cmGlobalVisualStudio8Generator.h
@@ -15,7 +15,6 @@ class cmGlobalVisualStudio8Generator : public cmGlobalVisualStudio71Generator
 public:
   cmGlobalVisualStudio8Generator(cmake* cm, const std::string& name,
                                  const std::string& platformName);
-  static cmGlobalGeneratorFactory* NewFactory();
 
   ///! Get the name for the generator.
   std::string GetName() const override { return this->Name; }
@@ -35,19 +34,6 @@ public:
    */
   void Configure() override;
 
-  /**
-   * Where does this version of Visual Studio look for macros for the
-   * current user? Returns the empty string if this version of Visual
-   * Studio does not implement support for VB macros.
-   */
-  std::string GetUserMacrosDirectory() override;
-
-  /**
-   * What is the reg key path to "vsmacros" for this version of Visual
-   * Studio?
-   */
-  std::string GetUserMacrosRegKeyBase() override;
-
   /** Return true if the target project file should have the option
       LinkLibraryDependencies and link to .sln dependencies. */
   bool NeedLinkLibraryDependencies(cmGeneratorTarget* target) override;
@@ -75,7 +61,6 @@ protected:
   virtual bool NeedsDeploy(cmStateEnums::TargetType type) const;
 
   static cmIDEFlagTable const* GetExtraFlagTableVS8();
-  void WriteSLNHeader(std::ostream& fout) override;
   void WriteSolutionConfigurations(
     std::ostream& fout, std::vector<std::string> const& configs) override;
   void WriteProjectConfigurations(
@@ -93,9 +78,5 @@ protected:
   std::string Name;
   std::string WindowsCEVersion;
   bool ExpressEdition;
-
-private:
-  class Factory;
-  friend class Factory;
 };
 #endif
diff --git a/Source/cmGlobalVisualStudio9Generator.h b/Source/cmGlobalVisualStudio9Generator.h
index 37efb9ccd..2aa6a91ee 100644
--- a/Source/cmGlobalVisualStudio9Generator.h
+++ b/Source/cmGlobalVisualStudio9Generator.h
@@ -38,6 +38,7 @@ public:
 
 protected:
   const char* GetIDEVersion() override { return "9.0"; }
+
 private:
   class Factory;
   friend class Factory;
diff --git a/Source/cmGlobalVisualStudioGenerator.cxx b/Source/cmGlobalVisualStudioGenerator.cxx
index a4570e160..4aa52c35c 100644
--- a/Source/cmGlobalVisualStudioGenerator.cxx
+++ b/Source/cmGlobalVisualStudioGenerator.cxx
@@ -458,9 +458,9 @@ bool IsVisualStudioMacrosFileRegistered(const std::string& macrosFile,
     lastWriteTime.dwHighDateTime = 0;
     lastWriteTime.dwLowDateTime = 0;
 
-    while (ERROR_SUCCESS == RegEnumKeyExW(hkey, index, subkeyname,
-                                          &cch_subkeyname, 0, keyclass,
-                                          &cch_keyclass, &lastWriteTime)) {
+    while (ERROR_SUCCESS ==
+           RegEnumKeyExW(hkey, index, subkeyname, &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);
@@ -734,44 +734,6 @@ bool cmGlobalVisualStudioGenerator::TargetIsFortranOnly(
   return false;
 }
 
-bool cmGlobalVisualStudioGenerator::TargetIsCSharpOnly(
-  cmGeneratorTarget const* gt)
-{
-  // check to see if this is a C# 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;
-    }
-    // Only "real" targets are allowed to be C# targets.
-    if (gt->Target->GetType() > cmStateEnums::OBJECT_LIBRARY) {
-      return false;
-    }
-  }
-  gt->GetLanguages(languages, "");
-  if (languages.size() == 1) {
-    if (*languages.begin() == "CSharp") {
-      return true;
-    }
-  }
-  return false;
-}
-
-bool cmGlobalVisualStudioGenerator::TargetCanBeReferenced(
-  cmGeneratorTarget const* gt)
-{
-  if (this->TargetIsCSharpOnly(gt)) {
-    return true;
-  }
-  if (gt->GetType() != cmStateEnums::SHARED_LIBRARY &&
-      gt->GetType() != cmStateEnums::EXECUTABLE) {
-    return false;
-  }
-  return true;
-}
-
 bool cmGlobalVisualStudioGenerator::TargetCompare::operator()(
   cmGeneratorTarget const* l, cmGeneratorTarget const* r) const
 {
diff --git a/Source/cmGlobalVisualStudioGenerator.h b/Source/cmGlobalVisualStudioGenerator.h
index 75b7f2200..07bc9a393 100644
--- a/Source/cmGlobalVisualStudioGenerator.h
+++ b/Source/cmGlobalVisualStudioGenerator.h
@@ -32,7 +32,6 @@ public:
   /** Known versions of Visual Studio.  */
   enum VSVersion
   {
-    VS8 = 80,
     VS9 = 90,
     VS10 = 100,
     VS11 = 110,
@@ -82,12 +81,6 @@ public:
   // return true if target is fortran only
   bool TargetIsFortranOnly(const cmGeneratorTarget* gt);
 
-  // return true if target is C# only
-  static bool TargetIsCSharpOnly(cmGeneratorTarget const* gt);
-
-  // return true if target can be referenced by C# targets
-  bool TargetCanBeReferenced(cmGeneratorTarget const* gt);
-
   /** Get the top-level registry key for this VS version.  */
   std::string GetRegistryBase();
 
diff --git a/Source/cmGlobalWatcomWMakeGenerator.cxx b/Source/cmGlobalWatcomWMakeGenerator.cxx
index 94cdb3848..558ef1585 100644
--- a/Source/cmGlobalWatcomWMakeGenerator.cxx
+++ b/Source/cmGlobalWatcomWMakeGenerator.cxx
@@ -7,6 +7,8 @@
 #include "cmState.h"
 #include "cmake.h"
 
+#include <ostream>
+
 cmGlobalWatcomWMakeGenerator::cmGlobalWatcomWMakeGenerator(cmake* cm)
   : cmGlobalUnixMakefileGenerator3(cm)
 {
@@ -47,3 +49,31 @@ void cmGlobalWatcomWMakeGenerator::GetDocumentation(
   entry.Name = cmGlobalWatcomWMakeGenerator::GetActualName();
   entry.Brief = "Generates Watcom WMake makefiles.";
 }
+
+void cmGlobalWatcomWMakeGenerator::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,
+  int /*jobs*/, bool verbose, std::vector<std::string> const& makeOptions)
+{
+  this->cmGlobalUnixMakefileGenerator3::GenerateBuildCommand(
+    makeCommand, makeProgram, projectName, projectDir, targetName, config,
+    fast, cmake::NO_BUILD_PARALLEL_LEVEL, verbose, makeOptions);
+}
+
+void cmGlobalWatcomWMakeGenerator::PrintBuildCommandAdvice(std::ostream& os,
+                                                           int jobs) const
+{
+  if (jobs != cmake::NO_BUILD_PARALLEL_LEVEL) {
+    // wmake does not support parallel build level
+
+    /* clang-format off */
+    os <<
+      "Warning: Watcom's WMake does not support parallel builds. "
+      "Ignoring parallel build command line option.\n";
+    /* clang-format on */
+  }
+
+  this->cmGlobalUnixMakefileGenerator3::PrintBuildCommandAdvice(
+    os, cmake::NO_BUILD_PARALLEL_LEVEL);
+}
diff --git a/Source/cmGlobalWatcomWMakeGenerator.h b/Source/cmGlobalWatcomWMakeGenerator.h
index e8b3a73c9..0d10d58f4 100644
--- a/Source/cmGlobalWatcomWMakeGenerator.h
+++ b/Source/cmGlobalWatcomWMakeGenerator.h
@@ -8,6 +8,7 @@
 #include "cmGlobalGeneratorFactory.h"
 #include "cmGlobalUnixMakefileGenerator3.h"
 
+#include <iosfwd>
 #include <string>
 #include <vector>
 
@@ -47,6 +48,19 @@ public:
 
   bool AllowNotParallel() const override { return false; }
   bool AllowDeleteOnError() const override { return false; }
+
+protected:
+  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, int jobs,
+                            bool verbose,
+                            std::vector<std::string> const& makeOptions =
+                              std::vector<std::string>()) override;
+
+  void PrintBuildCommandAdvice(std::ostream& os, int jobs) const override;
 };
 
 #endif
diff --git a/Source/cmGlobalXCodeGenerator.cxx b/Source/cmGlobalXCodeGenerator.cxx
index 2008a0b8c..e9a08bf7f 100644
--- a/Source/cmGlobalXCodeGenerator.cxx
+++ b/Source/cmGlobalXCodeGenerator.cxx
@@ -36,12 +36,12 @@
 struct cmLinkImplementation;
 
 #if defined(CMAKE_BUILD_WITH_CMAKE) && defined(__APPLE__)
-#define HAVE_APPLICATION_SERVICES
-#include <ApplicationServices/ApplicationServices.h>
+#  define HAVE_APPLICATION_SERVICES
+#  include <ApplicationServices/ApplicationServices.h>
 #endif
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
-#include "cmXMLParser.h"
+#  include "cmXMLParser.h"
 
 // parse the xml file storing the installed version of Xcode on
 // the machine
@@ -325,7 +325,7 @@ 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)
+  int jobs, bool /*verbose*/, std::vector<std::string> const& makeOptions)
 {
   // now build the test
   makeCommand.push_back(
@@ -356,6 +356,14 @@ void cmGlobalXCodeGenerator::GenerateBuildCommand(
   }
   makeCommand.push_back("-configuration");
   makeCommand.push_back(!config.empty() ? config : "Debug");
+
+  if (jobs != cmake::NO_BUILD_PARALLEL_LEVEL) {
+    makeCommand.push_back("-jobs");
+    if (jobs != cmake::DEFAULT_BUILD_PARALLEL_LEVEL) {
+      makeCommand.push_back(std::to_string(jobs));
+    }
+  }
+
   makeCommand.insert(makeCommand.end(), makeOptions.begin(),
                      makeOptions.end());
 }
@@ -458,7 +466,7 @@ void cmGlobalXCodeGenerator::AddExtraTargets(
   makeHelper.push_back(""); // placeholder, see below
 
   // Add ZERO_CHECK
-  bool regenerate = !mf->IsOn("CMAKE_SUPPRESS_REGENERATION");
+  bool regenerate = !this->GlobalSettingIsOn("CMAKE_SUPPRESS_REGENERATION");
   bool generateTopLevelProjectOnly =
     mf->IsOn("CMAKE_XCODE_GENERATE_TOP_LEVEL_PROJECT_ONLY");
   bool isTopLevel =
@@ -466,7 +474,7 @@ void cmGlobalXCodeGenerator::AddExtraTargets(
   if (regenerate && (isTopLevel || !generateTopLevelProjectOnly)) {
     this->CreateReRunCMakeFile(root, gens);
     std::string file =
-      this->ConvertToRelativeForMake(this->CurrentReRunCMakeMakefile.c_str());
+      this->ConvertToRelativeForMake(this->CurrentReRunCMakeMakefile);
     cmSystemTools::ReplaceString(file, "\\ ", " ");
     cmTarget* check = mf->AddUtilityCommand(
       CMAKE_CHECK_BUILD_SYSTEM_TARGET, cmMakefile::TargetOrigin::Generator,
@@ -537,6 +545,12 @@ void cmGlobalXCodeGenerator::CreateReRunCMakeFile(
   std::vector<std::string>::iterator new_end =
     std::unique(lfiles.begin(), lfiles.end());
   lfiles.erase(new_end, lfiles.end());
+
+  cmake* cm = this->GetCMakeInstance();
+  if (cm->DoWriteGlobVerifyTarget()) {
+    lfiles.emplace_back(cm->GetGlobVerifyStamp());
+  }
+
   this->CurrentReRunCMakeMakefile = root->GetCurrentBinaryDirectory();
   this->CurrentReRunCMakeMakefile += "/CMakeScripts";
   cmSystemTools::MakeDirectory(this->CurrentReRunCMakeMakefile.c_str());
@@ -553,20 +567,34 @@ void cmGlobalXCodeGenerator::CreateReRunCMakeFile(
 
   for (const auto& lfile : lfiles) {
     makefileStream << "TARGETS += $(subst $(space),$(spaceplus),$(wildcard "
-                   << this->ConvertToRelativeForMake(lfile.c_str()) << "))\n";
+                   << this->ConvertToRelativeForMake(lfile) << "))\n";
   }
+  makefileStream << "\n";
 
   std::string checkCache = root->GetBinaryDirectory();
   checkCache += "/";
   checkCache += cmake::GetCMakeFilesDirectoryPostSlash();
   checkCache += "cmake.check_cache";
 
-  makefileStream << "\n"
-                 << this->ConvertToRelativeForMake(checkCache.c_str())
+  if (cm->DoWriteGlobVerifyTarget()) {
+    makefileStream << ".NOTPARALLEL:\n\n";
+    makefileStream << ".PHONY: all VERIFY_GLOBS\n\n";
+    makefileStream << "all: VERIFY_GLOBS "
+                   << this->ConvertToRelativeForMake(checkCache) << "\n\n";
+    makefileStream << "VERIFY_GLOBS:\n";
+    makefileStream << "\t"
+                   << this->ConvertToRelativeForMake(
+                        cmSystemTools::GetCMakeCommand())
+                   << " -P "
+                   << this->ConvertToRelativeForMake(cm->GetGlobVerifyScript())
+                   << "\n\n";
+  }
+
+  makefileStream << this->ConvertToRelativeForMake(checkCache)
                  << ": $(TARGETS)\n";
   makefileStream << "\t"
                  << this->ConvertToRelativeForMake(
-                      cmSystemTools::GetCMakeCommand().c_str())
+                      cmSystemTools::GetCMakeCommand())
                  << " -H"
                  << this->ConvertToRelativeForMake(root->GetSourceDirectory())
                  << " -B"
@@ -1581,12 +1609,11 @@ void cmGlobalXCodeGenerator::AddCommandsToBuildPhase(
   }
 
   std::string cdir = this->CurrentLocalGenerator->GetCurrentBinaryDirectory();
-  cdir = this->ConvertToRelativeForMake(cdir.c_str());
+  cdir = this->ConvertToRelativeForMake(cdir);
   std::string makecmd = "make -C ";
   makecmd += cdir;
   makecmd += " -f ";
-  makecmd +=
-    this->ConvertToRelativeForMake((makefile + "$CONFIGURATION").c_str());
+  makecmd += this->ConvertToRelativeForMake((makefile + "$CONFIGURATION"));
   makecmd += " all";
   buildphase->AddAttribute("shellScript", this->CreateString(makecmd));
   buildphase->AddAttribute("showEnvVarsInLog", this->CreateString("0"));
@@ -1621,8 +1648,7 @@ void cmGlobalXCodeGenerator::CreateCustomRulesMakefile(
       const std::vector<std::string>& outputs = ccg.GetOutputs();
       if (!outputs.empty()) {
         for (auto const& output : outputs) {
-          makefileStream << "\\\n\t"
-                         << this->ConvertToRelativeForMake(output.c_str());
+          makefileStream << "\\\n\t" << this->ConvertToRelativeForMake(output);
         }
       } else {
         std::ostringstream str;
@@ -1643,8 +1669,7 @@ void cmGlobalXCodeGenerator::CreateCustomRulesMakefile(
         // There is at least one output, start the rule for it
         const char* sep = "";
         for (auto const& output : outputs) {
-          makefileStream << sep
-                         << this->ConvertToRelativeForMake(output.c_str());
+          makefileStream << sep << this->ConvertToRelativeForMake(output);
           sep = " ";
         }
         makefileStream << ": ";
@@ -1656,8 +1681,7 @@ void cmGlobalXCodeGenerator::CreateCustomRulesMakefile(
         std::string dep;
         if (this->CurrentLocalGenerator->GetRealDependency(d, configName,
                                                            dep)) {
-          makefileStream << "\\\n"
-                         << this->ConvertToRelativeForMake(dep.c_str());
+          makefileStream << "\\\n" << this->ConvertToRelativeForMake(dep);
         }
       }
       makefileStream << "\n";
@@ -1674,12 +1698,12 @@ void cmGlobalXCodeGenerator::CreateCustomRulesMakefile(
         // Build the command line in a single string.
         std::string cmd2 = ccg.GetCommand(c);
         cmSystemTools::ReplaceString(cmd2, "/./", "/");
-        cmd2 = this->ConvertToRelativeForMake(cmd2.c_str());
+        cmd2 = this->ConvertToRelativeForMake(cmd2);
         std::string cmd;
         std::string wd = ccg.GetWorkingDirectory();
         if (!wd.empty()) {
           cmd += "cd ";
-          cmd += this->ConvertToRelativeForMake(wd.c_str());
+          cmd += this->ConvertToRelativeForMake(wd);
           cmd += " && ";
         }
         cmd += cmd2;
@@ -3132,8 +3156,13 @@ void cmGlobalXCodeGenerator::ComputeArchitectures(cmMakefile* mf)
   if (this->Architectures.empty()) {
     // With no ARCHS we use ONLY_ACTIVE_ARCH.
     // Look up the arch that Xcode chooses in this case.
-    if (const char* arch = mf->GetDefinition("CMAKE_XCODE_CURRENT_ARCH")) {
+    if (const char* arch = mf->GetDefinition("CMAKE_XCODE_ARCHS")) {
       this->ObjectDirArchDefault = arch;
+      // We expect only one arch but choose the first just in case.
+      std::string::size_type pos = this->ObjectDirArchDefault.find(';');
+      if (pos != std::string::npos) {
+        this->ObjectDirArchDefault = this->ObjectDirArchDefault.substr(0, pos);
+      }
     }
   }
 
@@ -3200,7 +3229,7 @@ void cmGlobalXCodeGenerator::CreateXCodeDependHackTarget(
           gt->GetType() == cmStateEnums::SHARED_LIBRARY ||
           gt->GetType() == cmStateEnums::MODULE_LIBRARY) {
         std::string tfull = gt->GetFullPath(configName);
-        std::string trel = this->ConvertToRelativeForMake(tfull.c_str());
+        std::string trel = this->ConvertToRelativeForMake(tfull);
 
         // Add this target to the post-build phases of its dependencies.
         std::map<std::string, cmXCodeObject::StringVec>::const_iterator y =
@@ -3228,7 +3257,7 @@ void cmGlobalXCodeGenerator::CreateXCodeDependHackTarget(
           target->GetDependLibraries().find(configName);
         if (x != target->GetDependLibraries().end()) {
           for (auto const& deplib : x->second) {
-            std::string file = this->ConvertToRelativeForMake(deplib.c_str());
+            std::string file = this->ConvertToRelativeForMake(deplib);
             makefileStream << "\\\n\t" << file;
             dummyRules.insert(file);
           }
@@ -3243,7 +3272,7 @@ void cmGlobalXCodeGenerator::CreateXCodeDependHackTarget(
           d += objLibName;
           d += ".a";
 
-          std::string dependency = this->ConvertToRelativeForMake(d.c_str());
+          std::string dependency = this->ConvertToRelativeForMake(d);
           makefileStream << "\\\n\t" << dependency;
           dummyRules.insert(dependency);
         }
@@ -3251,8 +3280,7 @@ void cmGlobalXCodeGenerator::CreateXCodeDependHackTarget(
         // Write the action to remove the target if it is out of date.
         makefileStream << "\n";
         makefileStream << "\t/bin/rm -f "
-                       << this->ConvertToRelativeForMake(tfull.c_str())
-                       << "\n";
+                       << this->ConvertToRelativeForMake(tfull) << "\n";
         // if building for more than one architecture
         // then remove those executables as well
         if (this->Architectures.size() > 1) {
@@ -3264,8 +3292,7 @@ void cmGlobalXCodeGenerator::CreateXCodeDependHackTarget(
             universalFile += "/";
             universalFile += gt->GetFullName(configName);
             makefileStream << "\t/bin/rm -f "
-                           << this->ConvertToRelativeForMake(
-                                universalFile.c_str())
+                           << this->ConvertToRelativeForMake(universalFile)
                            << "\n";
           }
         }
@@ -3311,15 +3338,10 @@ void cmGlobalXCodeGenerator::OutputXCodeProject(
   }
   this->WriteXCodePBXProj(fout, root, generators);
 
-  // Since the lowest available Xcode version for testing was 6.4,
-  // I'm setting this as a limit then
-  if (this->XcodeVersion >= 64) {
-    if (root->GetMakefile()->GetCMakeInstance()->GetIsInTryCompile() ||
-        root->GetMakefile()->IsOn("CMAKE_XCODE_GENERATE_SCHEME")) {
-      this->OutputXCodeSharedSchemes(xcodeDir);
-      this->OutputXCodeWorkspaceSettings(xcodeDir);
-    }
+  if (this->IsGeneratingScheme(root)) {
+    this->OutputXCodeSharedSchemes(xcodeDir);
   }
+  this->OutputXCodeWorkspaceSettings(xcodeDir, root);
 
   this->ClearXCodeObjects();
 
@@ -3329,6 +3351,15 @@ void cmGlobalXCodeGenerator::OutputXCodeProject(
     root->GetBinaryDirectory());
 }
 
+bool cmGlobalXCodeGenerator::IsGeneratingScheme(cmLocalGenerator* root) const
+{
+  // Since the lowest available Xcode version for testing was 6.4,
+  // I'm setting this as a limit then
+  return this->XcodeVersion >= 64 &&
+    (root->GetMakefile()->GetCMakeInstance()->GetIsInTryCompile() ||
+     root->GetMakefile()->IsOn("CMAKE_XCODE_GENERATE_SCHEME"));
+}
+
 void cmGlobalXCodeGenerator::OutputXCodeSharedSchemes(
   const std::string& xcProjDir)
 {
@@ -3368,7 +3399,7 @@ void cmGlobalXCodeGenerator::OutputXCodeSharedSchemes(
 }
 
 void cmGlobalXCodeGenerator::OutputXCodeWorkspaceSettings(
-  const std::string& xcProjDir)
+  const std::string& xcProjDir, cmLocalGenerator* root)
 {
   std::string xcodeSharedDataDir = xcProjDir;
   xcodeSharedDataDir += "/project.xcworkspace/xcshareddata";
@@ -3390,8 +3421,15 @@ void cmGlobalXCodeGenerator::OutputXCodeWorkspaceSettings(
   xout.StartElement("plist");
   xout.Attribute("version", "1.0");
   xout.StartElement("dict");
-  xout.Element("key", "IDEWorkspaceSharedSettings_AutocreateContextsIfNeeded");
-  xout.Element("false");
+  if (this->XcodeVersion >= 100) {
+    xout.Element("key", "BuildSystemType");
+    xout.Element("string", "Original");
+  }
+  if (this->IsGeneratingScheme(root)) {
+    xout.Element("key",
+                 "IDEWorkspaceSharedSettings_AutocreateContextsIfNeeded");
+    xout.Element("false");
+  }
   xout.EndElement(); // dict
   xout.EndElement(); // plist
   xout.EndDocument();
diff --git a/Source/cmGlobalXCodeGenerator.h b/Source/cmGlobalXCodeGenerator.h
index 7c5117759..ccef6e21b 100644
--- a/Source/cmGlobalXCodeGenerator.h
+++ b/Source/cmGlobalXCodeGenerator.h
@@ -71,7 +71,8 @@ public:
                             const std::string& projectName,
                             const std::string& projectDir,
                             const std::string& targetName,
-                            const std::string& config, bool fast, bool verbose,
+                            const std::string& config, bool fast, int jobs,
+                            bool verbose,
                             std::vector<std::string> const& makeOptions =
                               std::vector<std::string>()) override;
 
@@ -181,9 +182,11 @@ private:
                           std::vector<cmLocalGenerator*>& generators);
   void OutputXCodeProject(cmLocalGenerator* root,
                           std::vector<cmLocalGenerator*>& generators);
+  bool IsGeneratingScheme(cmLocalGenerator* root) const;
   // Write shared scheme files for all the native targets
   void OutputXCodeSharedSchemes(const std::string& xcProjDir);
-  void OutputXCodeWorkspaceSettings(const std::string& xcProjDir);
+  void OutputXCodeWorkspaceSettings(const std::string& xcProjDir,
+                                    cmLocalGenerator* root);
   void WriteXCodePBXProj(std::ostream& fout, cmLocalGenerator* root,
                          std::vector<cmLocalGenerator*>& generators);
   cmXCodeObject* CreateXCodeFileReferenceFromPath(const std::string& fullpath,
diff --git a/Source/cmGraphAdjacencyList.h b/Source/cmGraphAdjacencyList.h
index 46cf87871..6a0a79912 100644
--- a/Source/cmGraphAdjacencyList.h
+++ b/Source/cmGraphAdjacencyList.h
@@ -23,6 +23,7 @@ public:
   operator int() const { return this->Dest; }
 
   bool IsStrong() const { return this->Strong; }
+
 private:
   int Dest;
   bool Strong;
diff --git a/Source/cmIDEOptions.cxx b/Source/cmIDEOptions.cxx
index 354b757c8..f996788d7 100644
--- a/Source/cmIDEOptions.cxx
+++ b/Source/cmIDEOptions.cxx
@@ -25,7 +25,7 @@ cmIDEOptions::~cmIDEOptions()
 {
 }
 
-void cmIDEOptions::HandleFlag(const char* flag)
+void cmIDEOptions::HandleFlag(std::string const& flag)
 {
   // If the last option was -D then this option is the definition.
   if (this->DoingDefine) {
@@ -49,26 +49,27 @@ void cmIDEOptions::HandleFlag(const char* flag)
   }
 
   // Look for known arguments.
-  if (flag[0] == '-' || (this->AllowSlash && flag[0] == '/')) {
+  size_t len = flag.length();
+  if (len > 0 && (flag[0] == '-' || (this->AllowSlash && flag[0] == '/'))) {
     // Look for preprocessor definitions.
-    if (this->AllowDefine && flag[1] == 'D') {
-      if (flag[2] == '\0') {
+    if (this->AllowDefine && len > 1 && flag[1] == 'D') {
+      if (len <= 2) {
         // The next argument will have the definition.
         this->DoingDefine = true;
       } else {
         // Store this definition.
-        this->Defines.push_back(flag + 2);
+        this->Defines.push_back(flag.substr(2));
       }
       return;
     }
     // Look for include directory.
-    if (this->AllowInclude && flag[1] == 'I') {
-      if (flag[2] == '\0') {
+    if (this->AllowInclude && len > 1 && flag[1] == 'I') {
+      if (len <= 2) {
         // The next argument will have the include directory.
         this->DoingInclude = true;
       } else {
         // Store this include directory.
-        this->Includes.push_back(flag + 2);
+        this->Includes.push_back(flag.substr(2));
       }
       return;
     }
@@ -92,8 +93,9 @@ void cmIDEOptions::HandleFlag(const char* flag)
 }
 
 bool cmIDEOptions::CheckFlagTable(cmIDEFlagTable const* table,
-                                  const char* flag, bool& flag_handled)
+                                  std::string const& flag, bool& flag_handled)
 {
+  const char* pf = flag.c_str() + 1;
   // Look for an entry in the flag table matching this flag.
   for (cmIDEFlagTable const* entry = table; entry->IDEName; ++entry) {
     bool entry_found = false;
@@ -102,17 +104,17 @@ bool cmIDEOptions::CheckFlagTable(cmIDEFlagTable const* table,
       // 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 ||
+      if ((strncmp(pf, entry->commandFlag, n) == 0 ||
            (entry->special & cmIDEFlagTable::CaseInsensitive &&
-            cmsysString_strncasecmp(flag + 1, entry->commandFlag, n))) &&
+            cmsysString_strncasecmp(pf, entry->commandFlag, n))) &&
           (!(entry->special & cmIDEFlagTable::UserRequired) ||
-           static_cast<int>(strlen(flag + 1)) > n)) {
-        this->FlagMapUpdate(entry, flag + n + 1);
+           static_cast<int>(strlen(pf)) > n)) {
+        this->FlagMapUpdate(entry, std::string(pf + n));
         entry_found = true;
       }
-    } else if (strcmp(flag + 1, entry->commandFlag) == 0 ||
+    } else if (strcmp(pf, entry->commandFlag) == 0 ||
                (entry->special & cmIDEFlagTable::CaseInsensitive &&
-                cmsysString_strcasecmp(flag + 1, entry->commandFlag) == 0)) {
+                cmsysString_strcasecmp(pf, entry->commandFlag) == 0)) {
       if (entry->special & cmIDEFlagTable::UserFollowing) {
         // This flag expects a value in the following argument.
         this->DoingFollowing = entry;
@@ -137,7 +139,7 @@ bool cmIDEOptions::CheckFlagTable(cmIDEFlagTable const* table,
 }
 
 void cmIDEOptions::FlagMapUpdate(cmIDEFlagTable const* entry,
-                                 const char* new_value)
+                                 std::string const& new_value)
 {
   if (entry->special & cmIDEFlagTable::UserIgnored) {
     // Ignore the user-specified value.
@@ -157,9 +159,9 @@ void cmIDEOptions::AddDefine(const std::string& def)
   this->Defines.push_back(def);
 }
 
-void cmIDEOptions::AddDefines(const char* defines)
+void cmIDEOptions::AddDefines(std::string const& defines)
 {
-  if (defines) {
+  if (!defines.empty()) {
     // Expand the list of definitions.
     cmSystemTools::ExpandListArgument(defines, this->Defines);
   }
@@ -179,9 +181,9 @@ void cmIDEOptions::AddInclude(const std::string& include)
   this->Includes.push_back(include);
 }
 
-void cmIDEOptions::AddIncludes(const char* includes)
+void cmIDEOptions::AddIncludes(std::string const& includes)
 {
-  if (includes) {
+  if (!includes.empty()) {
     // Expand the list of includes.
     cmSystemTools::ExpandListArgument(includes, this->Includes);
   }
diff --git a/Source/cmIDEOptions.h b/Source/cmIDEOptions.h
index 54cb52446..a4e575780 100644
--- a/Source/cmIDEOptions.h
+++ b/Source/cmIDEOptions.h
@@ -22,12 +22,12 @@ public:
 
   // Store definitions, includes and flags.
   void AddDefine(const std::string& define);
-  void AddDefines(const char* defines);
+  void AddDefines(std::string const& defines);
   void AddDefines(const std::vector<std::string>& defines);
   std::vector<std::string> const& GetDefines() const;
 
   void AddInclude(const std::string& includes);
-  void AddIncludes(const char* includes);
+  void AddIncludes(std::string const& includes);
   void AddIncludes(const std::vector<std::string>& includes);
   std::vector<std::string> const& GetIncludes() const;
 
@@ -95,11 +95,12 @@ protected:
     FlagTableCount = 16
   };
   cmIDEFlagTable const* FlagTable[FlagTableCount];
-  void HandleFlag(const char* flag);
-  bool CheckFlagTable(cmIDEFlagTable const* table, const char* flag,
+  void HandleFlag(std::string const& flag);
+  bool CheckFlagTable(cmIDEFlagTable const* table, std::string const& flag,
                       bool& flag_handled);
-  void FlagMapUpdate(cmIDEFlagTable const* entry, const char* new_value);
-  virtual void StoreUnknownFlag(const char* flag) = 0;
+  void FlagMapUpdate(cmIDEFlagTable const* entry,
+                     std::string const& new_value);
+  virtual void StoreUnknownFlag(std::string const& flag) = 0;
 };
 
 #endif
diff --git a/Source/cmIfCommand.cxx b/Source/cmIfCommand.cxx
index 4926f22d0..ae4041d8e 100644
--- a/Source/cmIfCommand.cxx
+++ b/Source/cmIfCommand.cxx
@@ -30,9 +30,9 @@ bool cmIfFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff,
                                             cmExecutionStatus& inStatus)
 {
   // we start by recording all the functions
-  if (!cmSystemTools::Strucmp(lff.Name.c_str(), "if")) {
+  if (lff.Name.Lower == "if") {
     this->ScopeDepth++;
-  } else if (!cmSystemTools::Strucmp(lff.Name.c_str(), "endif")) {
+  } else if (lff.Name.Lower == "endif") {
     this->ScopeDepth--;
     // if this is the endif for this if statement, then start executing
     if (!this->ScopeDepth) {
@@ -48,15 +48,14 @@ bool cmIfFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff,
       int scopeDepth = 0;
       for (cmListFileFunction const& func : this->Functions) {
         // keep track of scope depth
-        if (!cmSystemTools::Strucmp(func.Name.c_str(), "if")) {
+        if (func.Name.Lower == "if") {
           scopeDepth++;
         }
-        if (!cmSystemTools::Strucmp(func.Name.c_str(), "endif")) {
+        if (func.Name.Lower == "endif") {
           scopeDepth--;
         }
         // watch for our state change
-        if (scopeDepth == 0 &&
-            !cmSystemTools::Strucmp(func.Name.c_str(), "else")) {
+        if (scopeDepth == 0 && func.Name.Lower == "else") {
 
           if (this->ElseSeen) {
             cmListFileBacktrace bt = mf.GetBacktrace(func);
@@ -76,8 +75,7 @@ bool cmIfFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff,
           if (!this->IsBlocking && mf.GetCMakeInstance()->GetTrace()) {
             mf.PrintCommandTrace(func);
           }
-        } else if (scopeDepth == 0 &&
-                   !cmSystemTools::Strucmp(func.Name.c_str(), "elseif")) {
+        } else if (scopeDepth == 0 && func.Name.Lower == "elseif") {
           if (this->ElseSeen) {
             cmListFileBacktrace bt = mf.GetBacktrace(func);
             mf.GetCMakeInstance()->IssueMessage(
@@ -163,7 +161,7 @@ bool cmIfFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff,
 bool cmIfFunctionBlocker::ShouldRemove(const cmListFileFunction& lff,
                                        cmMakefile&)
 {
-  if (!cmSystemTools::Strucmp(lff.Name.c_str(), "endif")) {
+  if (lff.Name.Lower == "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) {
diff --git a/Source/cmIncludeCommand.cxx b/Source/cmIncludeCommand.cxx
index b42d75e1f..f86257826 100644
--- a/Source/cmIncludeCommand.cxx
+++ b/Source/cmIncludeCommand.cxx
@@ -95,8 +95,9 @@ bool cmIncludeCommand::InitialPass(std::vector<std::string> const& args,
         messageType = cmake::FATAL_ERROR;
     }
     if (modal) {
-      e << "The file\n  " << fname_abs << "\nwas generated by the export() "
-                                          "command.  It "
+      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 "
diff --git a/Source/cmIncludeExternalMSProjectCommand.cxx b/Source/cmIncludeExternalMSProjectCommand.cxx
index 85e8cd363..c9217d374 100644
--- a/Source/cmIncludeExternalMSProjectCommand.cxx
+++ b/Source/cmIncludeExternalMSProjectCommand.cxx
@@ -3,11 +3,11 @@
 #include "cmIncludeExternalMSProjectCommand.h"
 
 #ifdef _WIN32
-#include "cmGlobalGenerator.h"
-#include "cmMakefile.h"
-#include "cmStateTypes.h"
-#include "cmSystemTools.h"
-#include "cmTarget.h"
+#  include "cmGlobalGenerator.h"
+#  include "cmMakefile.h"
+#  include "cmStateTypes.h"
+#  include "cmSystemTools.h"
+#  include "cmTarget.h"
 #endif
 
 class cmExecutionStatus;
diff --git a/Source/cmInstallCommand.cxx b/Source/cmInstallCommand.cxx
index 394f976ca..87dcb188d 100644
--- a/Source/cmInstallCommand.cxx
+++ b/Source/cmInstallCommand.cxx
@@ -5,6 +5,7 @@
 #include "cmsys/Glob.hxx"
 #include <sstream>
 #include <stddef.h>
+#include <string.h>
 #include <utility>
 
 #include "cmAlgorithms.h"
@@ -32,16 +33,17 @@ class cmExecutionStatus;
 
 static cmInstallTargetGenerator* CreateInstallTargetGenerator(
   cmTarget& target, const cmInstallCommandArguments& args, bool impLib,
-  bool forceOpt = false)
+  bool forceOpt = false, bool namelink = false)
 {
   cmInstallGenerator::MessageLevel message =
     cmInstallGenerator::SelectMessageLevel(target.GetMakefile());
   target.SetHaveInstallRule(true);
+  const char* component = namelink ? args.GetNamelinkComponent().c_str()
+                                   : args.GetComponent().c_str();
   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);
+    args.GetPermissions().c_str(), args.GetConfigurations(), component,
+    message, args.GetExcludeFromAll(), args.GetOptional() || forceOpt);
 }
 
 static cmInstallFilesGenerator* CreateInstallFilesGenerator(
@@ -312,6 +314,20 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
       "The NAMELINK_SKIP option may be specified only following LIBRARY.");
     return false;
   }
+  if (archiveArgs.HasNamelinkComponent() ||
+      runtimeArgs.HasNamelinkComponent() ||
+      objectArgs.HasNamelinkComponent() ||
+      frameworkArgs.HasNamelinkComponent() ||
+      bundleArgs.HasNamelinkComponent() ||
+      privateHeaderArgs.HasNamelinkComponent() ||
+      publicHeaderArgs.HasNamelinkComponent() ||
+      resourceArgs.HasNamelinkComponent()) {
+    this->SetError(
+      "TARGETS given NAMELINK_COMPONENT option not in LIBRARY group.  "
+      "The NAMELINK_COMPONENT 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.");
@@ -334,8 +350,8 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
 
   // Check whether this is a DLL platform.
   bool dll_platform =
-    (this->Makefile->IsOn("WIN32") || this->Makefile->IsOn("CYGWIN") ||
-     this->Makefile->IsOn("MINGW"));
+    strcmp(this->Makefile->GetSafeDefinition("CMAKE_IMPORT_LIBRARY_SUFFIX"),
+           "") != 0;
 
   for (std::string const& tgt : targetList.GetVector()) {
 
@@ -360,17 +376,6 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
         this->SetError(e.str());
         return false;
       }
-      if (target->GetType() == cmStateEnums::OBJECT_LIBRARY) {
-        std::string reason;
-        if (!this->Makefile->GetGlobalGenerator()->HasKnownObjectFileLocation(
-              &reason)) {
-          std::ostringstream e;
-          e << "TARGETS given OBJECT library \"" << tgt
-            << "\" which may not be installed" << reason << ".";
-          this->SetError(e.str());
-          return false;
-        }
-      }
       // Store the target in the list to be installed.
       targets.push_back(target);
     } else {
@@ -387,6 +392,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
   // any files of the given type.
   bool installsArchive = false;
   bool installsLibrary = false;
+  bool installsNamelink = false;
   bool installsRuntime = false;
   bool installsObject = false;
   bool installsFramework = false;
@@ -401,6 +407,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
     cmTarget& target = *ti;
     cmInstallTargetGenerator* archiveGenerator = nullptr;
     cmInstallTargetGenerator* libraryGenerator = nullptr;
+    cmInstallTargetGenerator* namelinkGenerator = nullptr;
     cmInstallTargetGenerator* runtimeGenerator = nullptr;
     cmInstallTargetGenerator* objectGenerator = nullptr;
     cmInstallTargetGenerator* frameworkGenerator = nullptr;
@@ -463,9 +470,18 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
           } else {
             // The shared library uses the LIBRARY properties.
             if (!libraryArgs.GetDestination().empty()) {
-              libraryGenerator =
-                CreateInstallTargetGenerator(target, libraryArgs, false);
-              libraryGenerator->SetNamelinkMode(namelinkMode);
+              if (namelinkMode != cmInstallTargetGenerator::NamelinkModeOnly) {
+                libraryGenerator =
+                  CreateInstallTargetGenerator(target, libraryArgs, false);
+                libraryGenerator->SetNamelinkMode(
+                  cmInstallTargetGenerator::NamelinkModeSkip);
+              }
+              if (namelinkMode != cmInstallTargetGenerator::NamelinkModeSkip) {
+                namelinkGenerator = CreateInstallTargetGenerator(
+                  target, libraryArgs, false, false, true);
+                namelinkGenerator->SetNamelinkMode(
+                  cmInstallTargetGenerator::NamelinkModeOnly);
+              }
               namelinkOnly =
                 (namelinkMode == cmInstallTargetGenerator::NamelinkModeOnly);
             } else {
@@ -534,15 +550,23 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
       case cmStateEnums::OBJECT_LIBRARY: {
         // Objects use OBJECT properties.
         if (!objectArgs.GetDestination().empty()) {
+          // Verify that we know where the objects are to install them.
+          std::string reason;
+          if (!this->Makefile->GetGlobalGenerator()
+                 ->HasKnownObjectFileLocation(&reason)) {
+            std::ostringstream e;
+            e << "TARGETS given OBJECT library \"" << target.GetName()
+              << "\" whose objects may not be installed" << reason << ".";
+            this->SetError(e.str());
+            return false;
+          }
+
           objectGenerator =
             CreateInstallTargetGenerator(target, objectArgs, false);
         } else {
-          std::ostringstream e;
-          e << "TARGETS given no OBJECTS DESTINATION for object library "
-               "target \""
-            << target.GetName() << "\".";
-          this->SetError(e.str());
-          return false;
+          // Installing an OBJECT library without a destination transforms
+          // it to an INTERFACE library.  It installs no files but can be
+          // exported.
         }
       } break;
       case cmStateEnums::EXECUTABLE: {
@@ -686,6 +710,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
     // Keep track of whether we're installing anything in each category
     installsArchive = installsArchive || archiveGenerator != nullptr;
     installsLibrary = installsLibrary || libraryGenerator != nullptr;
+    installsNamelink = installsNamelink || namelinkGenerator != nullptr;
     installsRuntime = installsRuntime || runtimeGenerator != nullptr;
     installsObject = installsObject || objectGenerator != nullptr;
     installsFramework = installsFramework || frameworkGenerator != nullptr;
@@ -698,6 +723,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
 
     this->Makefile->AddInstallGenerator(archiveGenerator);
     this->Makefile->AddInstallGenerator(libraryGenerator);
+    this->Makefile->AddInstallGenerator(namelinkGenerator);
     this->Makefile->AddInstallGenerator(runtimeGenerator);
     this->Makefile->AddInstallGenerator(objectGenerator);
     this->Makefile->AddInstallGenerator(frameworkGenerator);
@@ -737,6 +763,10 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
     this->Makefile->GetGlobalGenerator()->AddInstallComponent(
       libraryArgs.GetComponent().c_str());
   }
+  if (installsNamelink) {
+    this->Makefile->GetGlobalGenerator()->AddInstallComponent(
+      libraryArgs.GetNamelinkComponent().c_str());
+  }
   if (installsRuntime) {
     this->Makefile->GetGlobalGenerator()->AddInstallComponent(
       runtimeArgs.GetComponent().c_str());
@@ -831,11 +861,13 @@ bool cmInstallCommand::HandleFilesMode(std::vector<std::string> const& args)
           messageType = cmake::FATAL_ERROR;
       }
       if (modal) {
-        e << "The file\n  " << file << "\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";
+        e << "The file\n  " << file
+          << "\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";
         this->Makefile->IssueMessage(messageType, e.str());
         if (messageType == cmake::FATAL_ERROR) {
           return false;
diff --git a/Source/cmInstallCommandArguments.cxx b/Source/cmInstallCommandArguments.cxx
index 7b79ab5c8..2d6dc1295 100644
--- a/Source/cmInstallCommandArguments.cxx
+++ b/Source/cmInstallCommandArguments.cxx
@@ -21,6 +21,7 @@ cmInstallCommandArguments::cmInstallCommandArguments(
   , ArgumentGroup()
   , Destination(&Parser, "DESTINATION", &ArgumentGroup)
   , Component(&Parser, "COMPONENT", &ArgumentGroup)
+  , NamelinkComponent(&Parser, "NAMELINK_COMPONENT", &ArgumentGroup)
   , ExcludeFromAll(&Parser, "EXCLUDE_FROM_ALL", &ArgumentGroup)
   , Rename(&Parser, "RENAME", &ArgumentGroup)
   , Permissions(&Parser, "PERMISSIONS", &ArgumentGroup)
@@ -59,6 +60,14 @@ const std::string& cmInstallCommandArguments::GetComponent() const
   return unspecifiedComponent;
 }
 
+const std::string& cmInstallCommandArguments::GetNamelinkComponent() const
+{
+  if (!this->NamelinkComponent.GetString().empty()) {
+    return this->NamelinkComponent.GetString();
+  }
+  return this->GetComponent();
+}
+
 const std::string& cmInstallCommandArguments::GetRename() const
 {
   if (!this->Rename.GetString().empty()) {
@@ -125,6 +134,17 @@ bool cmInstallCommandArguments::GetNamelinkSkip() const
   return false;
 }
 
+bool cmInstallCommandArguments::HasNamelinkComponent() const
+{
+  if (!this->NamelinkComponent.GetString().empty()) {
+    return true;
+  }
+  if (this->GenericArguments != nullptr) {
+    return this->GenericArguments->HasNamelinkComponent();
+  }
+  return false;
+}
+
 const std::vector<std::string>& cmInstallCommandArguments::GetConfigurations()
   const
 {
diff --git a/Source/cmInstallCommandArguments.h b/Source/cmInstallCommandArguments.h
index a576e7202..ee6e86597 100644
--- a/Source/cmInstallCommandArguments.h
+++ b/Source/cmInstallCommandArguments.h
@@ -26,6 +26,7 @@ public:
 
   const std::string& GetDestination() const;
   const std::string& GetComponent() const;
+  const std::string& GetNamelinkComponent() const;
   bool GetExcludeFromAll() const;
   const std::string& GetRename() const;
   const std::string& GetPermissions() const;
@@ -33,6 +34,7 @@ public:
   bool GetOptional() const;
   bool GetNamelinkOnly() const;
   bool GetNamelinkSkip() const;
+  bool HasNamelinkComponent() const;
 
   // once HandleDirectoryMode() is also switched to using
   // cmInstallCommandArguments then these two functions can become non-static
@@ -45,6 +47,7 @@ private:
   cmInstallCommandArguments(); // disabled
   cmCAString Destination;
   cmCAString Component;
+  cmCAString NamelinkComponent;
   cmCAEnabler ExcludeFromAll;
   cmCAString Rename;
   cmCAStringVector Permissions;
diff --git a/Source/cmInstallExportGenerator.cxx b/Source/cmInstallExportGenerator.cxx
index 5990f3059..d441e4138 100644
--- a/Source/cmInstallExportGenerator.cxx
+++ b/Source/cmInstallExportGenerator.cxx
@@ -7,7 +7,7 @@
 #include <utility>
 
 #ifdef CMAKE_BUILD_WITH_CMAKE
-#include "cmExportInstallAndroidMKGenerator.h"
+#  include "cmExportInstallAndroidMKGenerator.h"
 #endif
 #include "cmExportInstallFileGenerator.h"
 #include "cmExportSet.h"
diff --git a/Source/cmInstallFilesCommand.h b/Source/cmInstallFilesCommand.h
index 19f255902..a52f45e05 100644
--- a/Source/cmInstallFilesCommand.h
+++ b/Source/cmInstallFilesCommand.h
@@ -48,7 +48,7 @@ protected:
 
 private:
   std::vector<std::string> FinalArgs;
-  bool IsFilesForm;
+  bool IsFilesForm = false;
   std::string Destination;
   std::vector<std::string> Files;
 };
diff --git a/Source/cmInstallTargetGenerator.cxx b/Source/cmInstallTargetGenerator.cxx
index a9b4908e5..e0afa2d4d 100644
--- a/Source/cmInstallTargetGenerator.cxx
+++ b/Source/cmInstallTargetGenerator.cxx
@@ -135,7 +135,7 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(
       filesFrom.push_back(std::move(from1));
       filesTo.push_back(std::move(to1));
       std::string targetNameImportLib;
-      if (this->Target->GetImplibGNUtoMS(targetNameImport,
+      if (this->Target->GetImplibGNUtoMS(config, targetNameImport,
                                          targetNameImportLib)) {
         filesFrom.push_back(fromDirConfig + targetNameImportLib);
         filesTo.push_back(toDir + targetNameImportLib);
@@ -201,7 +201,7 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(
       filesFrom.push_back(std::move(from1));
       filesTo.push_back(std::move(to1));
       std::string targetNameImportLib;
-      if (this->Target->GetImplibGNUtoMS(targetNameImport,
+      if (this->Target->GetImplibGNUtoMS(config, targetNameImport,
                                          targetNameImportLib)) {
         filesFrom.push_back(fromDirConfig + targetNameImportLib);
         filesTo.push_back(toDir + targetNameImportLib);
@@ -398,7 +398,7 @@ std::string cmInstallTargetGenerator::GetInstallFilename(
                                targetNamePDB, config);
     if (nameType == NameImplib) {
       // Use the import library name.
-      if (!target->GetImplibGNUtoMS(targetNameImport, fname,
+      if (!target->GetImplibGNUtoMS(config, targetNameImport, fname,
                                     "${CMAKE_IMPORT_LIBRARY_SUFFIX}")) {
         fname = targetNameImport;
       }
@@ -419,7 +419,7 @@ std::string cmInstallTargetGenerator::GetInstallFilename(
                             targetNameImport, targetNamePDB, config);
     if (nameType == NameImplib) {
       // Use the import library name.
-      if (!target->GetImplibGNUtoMS(targetNameImport, fname,
+      if (!target->GetImplibGNUtoMS(config, targetNameImport, fname,
                                     "${CMAKE_IMPORT_LIBRARY_SUFFIX}")) {
         fname = targetNameImport;
       }
diff --git a/Source/cmLinkLibrariesCommand.cxx b/Source/cmLinkLibrariesCommand.cxx
index 708ec8c00..13f6baef3 100644
--- a/Source/cmLinkLibrariesCommand.cxx
+++ b/Source/cmLinkLibrariesCommand.cxx
@@ -13,7 +13,7 @@ bool cmLinkLibrariesCommand::InitialPass(std::vector<std::string> const& args,
   if (args.empty()) {
     return true;
   }
-  // add libraries, nothe that there is an optional prefix
+  // add libraries, note 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) {
diff --git a/Source/cmLinkLineDeviceComputer.cxx b/Source/cmLinkLineDeviceComputer.cxx
index 3beeae321..557fa41d2 100644
--- a/Source/cmLinkLineDeviceComputer.cxx
+++ b/Source/cmLinkLineDeviceComputer.cxx
@@ -3,9 +3,9 @@
 
 #include "cmLinkLineDeviceComputer.h"
 
-#include <set>
 #include <sstream>
 
+#include "cmAlgorithms.h"
 #include "cmComputeLinkInformation.h"
 #include "cmGeneratorTarget.h"
 #include "cmGlobalNinjaGenerator.h"
@@ -32,38 +32,32 @@ std::string cmLinkLineDeviceComputer::ComputeLinkLibraries(
   ItemVector const& items = cli.GetItems();
   std::string config = cli.GetConfig();
   for (auto const& item : items) {
-    if (!item.Target) {
-      continue;
-    }
-
-    bool skippable = false;
-    switch (item.Target->GetType()) {
-      case cmStateEnums::SHARED_LIBRARY:
-      case cmStateEnums::MODULE_LIBRARY:
-      case cmStateEnums::INTERFACE_LIBRARY:
-        skippable = true;
-        break;
-      case cmStateEnums::STATIC_LIBRARY:
-        // If a static library is resolving its device linking, it should
-        // be removed for other device linking
-        skippable =
-          item.Target->GetPropertyAsBool("CUDA_RESOLVE_DEVICE_SYMBOLS");
-        break;
-      default:
-        break;
-    }
-
-    if (skippable) {
-      continue;
-    }
-
-    std::set<std::string> langs;
-    item.Target->GetLanguages(langs, config);
-    if (langs.count("CUDA") == 0) {
-      continue;
+    if (item.Target) {
+      bool skip = false;
+      switch (item.Target->GetType()) {
+        case cmStateEnums::MODULE_LIBRARY:
+        case cmStateEnums::INTERFACE_LIBRARY:
+          skip = true;
+          break;
+        case cmStateEnums::STATIC_LIBRARY:
+          skip = item.Target->GetPropertyAsBool("CUDA_RESOLVE_DEVICE_SYMBOLS");
+          break;
+        default:
+          break;
+      }
+      if (skip) {
+        continue;
+      }
     }
 
     if (item.IsPath) {
+      // nvcc understands absolute paths to libraries ending in '.a' should
+      // be passed to nvlink.  Other extensions like '.so' or '.dylib' are
+      // rejected by the nvcc front-end even though nvlink knows to ignore
+      // them.  Bypass the front-end via '-Xnvlink'.
+      if (!cmHasLiteralSuffix(item.Value, ".a")) {
+        fout << "-Xnvlink ";
+      }
       fout << this->ConvertToOutputFormat(
         this->ConvertToLinkReference(item.Value));
     } else {
diff --git a/Source/cmListCommand.cxx b/Source/cmListCommand.cxx
index ae4f0a84e..1ac2cc2bf 100644
--- a/Source/cmListCommand.cxx
+++ b/Source/cmListCommand.cxx
@@ -5,14 +5,19 @@
 #include "cmsys/RegularExpression.hxx"
 #include <algorithm>
 #include <assert.h>
+#include <functional>
 #include <iterator>
+#include <set>
 #include <sstream>
+#include <stdexcept>
 #include <stdio.h>
 #include <stdlib.h> // required for atoi
 
 #include "cmAlgorithms.h"
+#include "cmGeneratorExpression.h"
 #include "cmMakefile.h"
 #include "cmPolicies.h"
+#include "cmStringReplaceHelper.h"
 #include "cmSystemTools.h"
 #include "cmake.h"
 
@@ -42,6 +47,9 @@ bool cmListCommand::InitialPass(std::vector<std::string> const& args,
   if (subCommand == "INSERT") {
     return this->HandleInsertCommand(args);
   }
+  if (subCommand == "JOIN") {
+    return this->HandleJoinCommand(args);
+  }
   if (subCommand == "REMOVE_AT") {
     return this->HandleRemoveAtCommand(args);
   }
@@ -51,9 +59,15 @@ bool cmListCommand::InitialPass(std::vector<std::string> const& args,
   if (subCommand == "REMOVE_DUPLICATES") {
     return this->HandleRemoveDuplicatesCommand(args);
   }
+  if (subCommand == "TRANSFORM") {
+    return this->HandleTransformCommand(args);
+  }
   if (subCommand == "SORT") {
     return this->HandleSortCommand(args);
   }
+  if (subCommand == "SUBLIST") {
+    return this->HandleSublistCommand(args);
+  }
   if (subCommand == "REVERSE") {
     return this->HandleReverseCommand(args);
   }
@@ -294,6 +308,34 @@ bool cmListCommand::HandleInsertCommand(std::vector<std::string> const& args)
   return true;
 }
 
+bool cmListCommand::HandleJoinCommand(std::vector<std::string> const& args)
+{
+  if (args.size() != 4) {
+    std::ostringstream error;
+    error << "sub-command JOIN requires three arguments (" << args.size() - 1
+          << " found).";
+    this->SetError(error.str());
+    return false;
+  }
+
+  const std::string& listName = args[1];
+  const std::string& glue = args[2];
+  const std::string& variableName = args[3];
+
+  // expand the variable
+  std::vector<std::string> varArgsExpanded;
+  if (!this->GetList(varArgsExpanded, listName)) {
+    this->Makefile->AddDefinition(variableName, "");
+    return true;
+  }
+
+  std::string value =
+    cmJoin(cmMakeRange(varArgsExpanded.begin(), varArgsExpanded.end()), glue);
+
+  this->Makefile->AddDefinition(variableName, value.c_str());
+  return true;
+}
+
 bool cmListCommand::HandleRemoveItemCommand(
   std::vector<std::string> const& args)
 {
@@ -373,6 +415,554 @@ bool cmListCommand::HandleRemoveDuplicatesCommand(
   return true;
 }
 
+// Helpers for list(TRANSFORM <list> ...)
+namespace {
+using transform_type = std::function<std::string(const std::string&)>;
+
+class transform_error : public std::runtime_error
+{
+public:
+  transform_error(const std::string& error)
+    : std::runtime_error(error)
+  {
+  }
+};
+
+class TransformSelector
+{
+public:
+  virtual ~TransformSelector() {}
+
+  std::string Tag;
+
+  virtual bool Validate(std::size_t count = 0) = 0;
+
+  virtual bool InSelection(const std::string&) = 0;
+
+  virtual void Transform(std::vector<std::string>& list,
+                         const transform_type& transform)
+  {
+    std::transform(list.begin(), list.end(), list.begin(), transform);
+  }
+
+protected:
+  TransformSelector(std::string&& tag)
+    : Tag(std::move(tag))
+  {
+  }
+};
+class TransformNoSelector : public TransformSelector
+{
+public:
+  TransformNoSelector()
+    : TransformSelector("NO SELECTOR")
+  {
+  }
+
+  bool Validate(std::size_t) override { return true; }
+
+  bool InSelection(const std::string&) override { return true; }
+};
+class TransformSelectorRegex : public TransformSelector
+{
+public:
+  TransformSelectorRegex(const std::string& regex)
+    : TransformSelector("REGEX")
+    , Regex(regex)
+  {
+  }
+
+  bool Validate(std::size_t) override { return this->Regex.is_valid(); }
+
+  bool InSelection(const std::string& value) override
+  {
+    return this->Regex.find(value);
+  }
+
+  cmsys::RegularExpression Regex;
+};
+class TransformSelectorIndexes : public TransformSelector
+{
+public:
+  std::vector<int> Indexes;
+
+  bool InSelection(const std::string&) override { return true; }
+
+  void Transform(std::vector<std::string>& list,
+                 const transform_type& transform) override
+  {
+    this->Validate(list.size());
+
+    for (auto index : this->Indexes) {
+      list[index] = transform(list[index]);
+    }
+  }
+
+protected:
+  TransformSelectorIndexes(std::string&& tag)
+    : TransformSelector(std::move(tag))
+  {
+  }
+  TransformSelectorIndexes(std::string&& tag, std::vector<int>&& indexes)
+    : TransformSelector(std::move(tag))
+    , Indexes(indexes)
+  {
+  }
+
+  int NormalizeIndex(int index, std::size_t count)
+  {
+    if (index < 0) {
+      index = static_cast<int>(count) + index;
+    }
+    if (index < 0 || count <= static_cast<std::size_t>(index)) {
+      std::ostringstream str;
+      str << "sub-command TRANSFORM, selector " << this->Tag
+          << ", index: " << index << " out of range (-" << count << ", "
+          << count - 1 << ").";
+      throw transform_error(str.str());
+    }
+    return index;
+  }
+};
+class TransformSelectorAt : public TransformSelectorIndexes
+{
+public:
+  TransformSelectorAt(std::vector<int>&& indexes)
+    : TransformSelectorIndexes("AT", std::move(indexes))
+  {
+  }
+
+  bool Validate(std::size_t count) override
+  {
+    decltype(Indexes) indexes;
+
+    for (auto index : Indexes) {
+      indexes.push_back(this->NormalizeIndex(index, count));
+    }
+    this->Indexes = std::move(indexes);
+
+    return true;
+  }
+};
+class TransformSelectorFor : public TransformSelectorIndexes
+{
+public:
+  TransformSelectorFor(int start, int stop, int step)
+    : TransformSelectorIndexes("FOR")
+    , Start(start)
+    , Stop(stop)
+    , Step(step)
+  {
+  }
+
+  bool Validate(std::size_t count) override
+  {
+    this->Start = this->NormalizeIndex(this->Start, count);
+    this->Stop = this->NormalizeIndex(this->Stop, count);
+
+    // compute indexes
+    auto size = (this->Stop - this->Start + 1) / this->Step;
+    if ((this->Stop - this->Start + 1) % this->Step != 0) {
+      size += 1;
+    }
+
+    this->Indexes.resize(size);
+    auto start = this->Start, step = this->Step;
+    std::generate(this->Indexes.begin(), this->Indexes.end(),
+                  [&start, step]() -> int {
+                    auto r = start;
+                    start += step;
+                    return r;
+                  });
+
+    return true;
+  }
+
+private:
+  int Start, Stop, Step;
+};
+
+class TransformAction
+{
+public:
+  virtual ~TransformAction() {}
+
+  virtual std::string Transform(const std::string& input) = 0;
+};
+class TransformReplace : public TransformAction
+{
+public:
+  TransformReplace(const std::vector<std::string>& arguments,
+                   cmMakefile* makefile)
+    : ReplaceHelper(arguments[0], arguments[1], makefile)
+  {
+    makefile->ClearMatches();
+
+    if (!this->ReplaceHelper.IsRegularExpressionValid()) {
+      std::ostringstream error;
+      error
+        << "sub-command TRANSFORM, action REPLACE: Failed to compile regex \""
+        << arguments[0] << "\".";
+      throw transform_error(error.str());
+    }
+    if (!this->ReplaceHelper.IsReplaceExpressionValid()) {
+      std::ostringstream error;
+      error << "sub-command TRANSFORM, action REPLACE: "
+            << this->ReplaceHelper.GetError() << ".";
+      throw transform_error(error.str());
+    }
+  }
+
+  std::string Transform(const std::string& input) override
+  {
+    // Scan through the input for all matches.
+    std::string output;
+
+    if (!this->ReplaceHelper.Replace(input, output)) {
+      std::ostringstream error;
+      error << "sub-command TRANSFORM, action REPLACE: "
+            << this->ReplaceHelper.GetError() << ".";
+      throw transform_error(error.str());
+    }
+
+    return output;
+  }
+
+private:
+  cmStringReplaceHelper ReplaceHelper;
+};
+}
+
+bool cmListCommand::HandleTransformCommand(
+  std::vector<std::string> const& args)
+{
+  if (args.size() < 3) {
+    this->SetError(
+      "sub-command TRANSFORM requires an action to be specified.");
+    return false;
+  }
+
+  // Structure collecting all elements of the command
+  struct Command
+  {
+    Command(const std::string& listName)
+      : ListName(listName)
+      , OutputName(listName)
+    {
+    }
+
+    std::string Name;
+    std::string ListName;
+    std::vector<std::string> Arguments;
+    std::unique_ptr<TransformAction> Action;
+    std::unique_ptr<TransformSelector> Selector;
+    std::string OutputName;
+  } command(args[1]);
+
+  // Descriptor of action
+  // Arity: number of arguments required for the action
+  // Transform: lambda function implementing the action
+  struct ActionDescriptor
+  {
+    ActionDescriptor(const std::string& name)
+      : Name(name)
+    {
+    }
+    ActionDescriptor(const std::string& name, int arity,
+                     const transform_type& transform)
+      : Name(name)
+      , Arity(arity)
+      , Transform(transform)
+    {
+    }
+
+    operator const std::string&() const { return Name; }
+
+    std::string Name;
+    int Arity = 0;
+    transform_type Transform;
+  };
+
+  // Build a set of supported actions.
+  std::set<ActionDescriptor,
+           std::function<bool(const std::string&, const std::string&)>>
+    descriptors(
+      [](const std::string& x, const std::string& y) { return x < y; });
+  descriptors = { { "APPEND", 1,
+                    [&command](const std::string& s) -> std::string {
+                      if (command.Selector->InSelection(s)) {
+                        return s + command.Arguments[0];
+                      }
+
+                      return s;
+                    } },
+                  { "PREPEND", 1,
+                    [&command](const std::string& s) -> std::string {
+                      if (command.Selector->InSelection(s)) {
+                        return command.Arguments[0] + s;
+                      }
+
+                      return s;
+                    } },
+                  { "TOUPPER", 0,
+                    [&command](const std::string& s) -> std::string {
+                      if (command.Selector->InSelection(s)) {
+                        return cmSystemTools::UpperCase(s);
+                      }
+
+                      return s;
+                    } },
+                  { "TOLOWER", 0,
+                    [&command](const std::string& s) -> std::string {
+                      if (command.Selector->InSelection(s)) {
+                        return cmSystemTools::LowerCase(s);
+                      }
+
+                      return s;
+                    } },
+                  { "STRIP", 0,
+                    [&command](const std::string& s) -> std::string {
+                      if (command.Selector->InSelection(s)) {
+                        return cmSystemTools::TrimWhitespace(s);
+                      }
+
+                      return s;
+                    } },
+                  { "GENEX_STRIP", 0,
+                    [&command](const std::string& s) -> std::string {
+                      if (command.Selector->InSelection(s)) {
+                        return cmGeneratorExpression::Preprocess(
+                          s,
+                          cmGeneratorExpression::StripAllGeneratorExpressions);
+                      }
+
+                      return s;
+                    } },
+                  { "REPLACE", 2,
+                    [&command](const std::string& s) -> std::string {
+                      if (command.Selector->InSelection(s)) {
+                        return command.Action->Transform(s);
+                      }
+
+                      return s;
+                    } } };
+
+  using size_type = std::vector<std::string>::size_type;
+  size_type index = 2;
+
+  // Parse all possible function parameters
+  auto descriptor = descriptors.find(args[index]);
+
+  if (descriptor == descriptors.end()) {
+    std::ostringstream error;
+    error << " sub-command TRANSFORM, " << args[index] << " invalid action.";
+    this->SetError(error.str());
+    return false;
+  }
+
+  // Action arguments
+  index += 1;
+  if (args.size() < index + descriptor->Arity) {
+    std::ostringstream error;
+    error << "sub-command TRANSFORM, action " << descriptor->Name
+          << " expects " << descriptor->Arity << " argument(s).";
+    this->SetError(error.str());
+    return false;
+  }
+
+  command.Name = descriptor->Name;
+  index += descriptor->Arity;
+  if (descriptor->Arity > 0) {
+    command.Arguments =
+      std::vector<std::string>(args.begin() + 3, args.begin() + index);
+  }
+
+  if (command.Name == "REPLACE") {
+    try {
+      command.Action =
+        cm::make_unique<TransformReplace>(command.Arguments, this->Makefile);
+    } catch (const transform_error& e) {
+      this->SetError(e.what());
+      return false;
+    }
+  }
+
+  const std::string REGEX{ "REGEX" }, AT{ "AT" }, FOR{ "FOR" },
+    OUTPUT_VARIABLE{ "OUTPUT_VARIABLE" };
+
+  // handle optional arguments
+  while (args.size() > index) {
+    if ((args[index] == REGEX || args[index] == AT || args[index] == FOR) &&
+        command.Selector) {
+      std::ostringstream error;
+      error << "sub-command TRANSFORM, selector already specified ("
+            << command.Selector->Tag << ").";
+      this->SetError(error.str());
+      return false;
+    }
+
+    // REGEX selector
+    if (args[index] == REGEX) {
+      if (args.size() == ++index) {
+        this->SetError("sub-command TRANSFORM, selector REGEX expects "
+                       "'regular expression' argument.");
+        return false;
+      }
+
+      command.Selector = cm::make_unique<TransformSelectorRegex>(args[index]);
+      if (!command.Selector->Validate()) {
+        std::ostringstream error;
+        error << "sub-command TRANSFORM, selector REGEX failed to compile "
+                 "regex \"";
+        error << args[index] << "\".";
+        this->SetError(error.str());
+        return false;
+      }
+
+      index += 1;
+      continue;
+    }
+
+    // AT selector
+    if (args[index] == AT) {
+      // get all specified indexes
+      std::vector<int> indexes;
+      while (args.size() > ++index) {
+        std::size_t pos;
+        int value;
+
+        try {
+          value = std::stoi(args[index], &pos);
+          if (pos != args[index].length()) {
+            // this is not a number, stop processing
+            break;
+          }
+          indexes.push_back(value);
+        } catch (const std::invalid_argument&) {
+          // this is not a number, stop processing
+          break;
+        }
+      }
+
+      if (indexes.empty()) {
+        this->SetError(
+          "sub-command TRANSFORM, selector AT expects at least one "
+          "numeric value.");
+        return false;
+      }
+
+      command.Selector =
+        cm::make_unique<TransformSelectorAt>(std::move(indexes));
+
+      continue;
+    }
+
+    // FOR selector
+    if (args[index] == FOR) {
+      if (args.size() <= ++index + 1) {
+        this->SetError("sub-command TRANSFORM, selector FOR expects, at least,"
+                       " two arguments.");
+        return false;
+      }
+
+      int start = 0, stop = 0, step = 1;
+      bool valid = true;
+      try {
+        std::size_t pos;
+
+        start = std::stoi(args[index], &pos);
+        if (pos != args[index].length()) {
+          // this is not a number
+          valid = false;
+        } else {
+          stop = std::stoi(args[++index], &pos);
+          if (pos != args[index].length()) {
+            // this is not a number
+            valid = false;
+          }
+        }
+      } catch (const std::invalid_argument&) {
+        // this is not numbers
+        valid = false;
+      }
+      if (!valid) {
+        this->SetError("sub-command TRANSFORM, selector FOR expects, "
+                       "at least, two numeric values.");
+        return false;
+      }
+      // try to read a third numeric value for step
+      if (args.size() > ++index) {
+        try {
+          std::size_t pos;
+
+          step = std::stoi(args[index], &pos);
+          if (pos != args[index].length()) {
+            // this is not a number
+            step = 1;
+          } else {
+            index += 1;
+          }
+        } catch (const std::invalid_argument&) {
+          // this is not number, ignore exception
+        }
+      }
+
+      if (step < 0) {
+        this->SetError("sub-command TRANSFORM, selector FOR expects "
+                       "non negative numeric value for <step>.");
+      }
+
+      command.Selector =
+        cm::make_unique<TransformSelectorFor>(start, stop, step);
+
+      continue;
+    }
+
+    // output variable
+    if (args[index] == OUTPUT_VARIABLE) {
+      if (args.size() == ++index) {
+        this->SetError("sub-command TRANSFORM, OUTPUT_VARIABLE "
+                       "expects variable name argument.");
+        return false;
+      }
+
+      command.OutputName = args[index++];
+      continue;
+    }
+
+    std::ostringstream error;
+    error << "sub-command TRANSFORM, '"
+          << cmJoin(cmMakeRange(args).advance(index), " ")
+          << "': unexpected argument(s).";
+    this->SetError(error.str());
+    return false;
+  }
+
+  // expand the list variable
+  std::vector<std::string> varArgsExpanded;
+  if (!this->GetList(varArgsExpanded, command.ListName)) {
+    this->Makefile->AddDefinition(command.OutputName, "");
+    return true;
+  }
+
+  if (!command.Selector) {
+    // no selector specified, apply transformation to all elements
+    command.Selector = cm::make_unique<TransformNoSelector>();
+  }
+
+  try {
+    command.Selector->Transform(varArgsExpanded, descriptor->Transform);
+  } catch (const transform_error& e) {
+    this->SetError(e.what());
+    return false;
+  }
+
+  this->Makefile->AddDefinition(command.OutputName,
+                                cmJoin(varArgsExpanded, ";").c_str());
+
+  return true;
+}
+
 bool cmListCommand::HandleSortCommand(std::vector<std::string> const& args)
 {
   assert(args.size() >= 2);
@@ -396,6 +986,55 @@ bool cmListCommand::HandleSortCommand(std::vector<std::string> const& args)
   return true;
 }
 
+bool cmListCommand::HandleSublistCommand(std::vector<std::string> const& args)
+{
+  if (args.size() != 5) {
+    std::ostringstream error;
+    error << "sub-command SUBLIST requires four arguments (" << args.size() - 1
+          << " found).";
+    this->SetError(error.str());
+    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) || varArgsExpanded.empty()) {
+    this->Makefile->AddDefinition(variableName, "");
+    return true;
+  }
+
+  const int start = atoi(args[2].c_str());
+  const int length = atoi(args[3].c_str());
+
+  using size_type = decltype(varArgsExpanded)::size_type;
+
+  if (start < 0 || size_type(start) >= varArgsExpanded.size()) {
+    std::ostringstream error;
+    error << "begin index: " << start << " is out of range 0 - "
+          << varArgsExpanded.size() - 1;
+    this->SetError(error.str());
+    return false;
+  }
+  if (length < -1) {
+    std::ostringstream error;
+    error << "length: " << length << " should be -1 or greater";
+    this->SetError(error.str());
+    return false;
+  }
+
+  const size_type end =
+    (length == -1 || size_type(start + length) > varArgsExpanded.size())
+    ? varArgsExpanded.size()
+    : size_type(start + length);
+  std::vector<std::string> sublist(varArgsExpanded.begin() + start,
+                                   varArgsExpanded.begin() + end);
+  this->Makefile->AddDefinition(variableName, cmJoin(sublist, ";").c_str());
+  return true;
+}
+
 bool cmListCommand::HandleRemoveAtCommand(std::vector<std::string> const& args)
 {
   if (args.size() < 3) {
diff --git a/Source/cmListCommand.h b/Source/cmListCommand.h
index 29653998c..76a985657 100644
--- a/Source/cmListCommand.h
+++ b/Source/cmListCommand.h
@@ -37,10 +37,13 @@ protected:
   bool HandleAppendCommand(std::vector<std::string> const& args);
   bool HandleFindCommand(std::vector<std::string> const& args);
   bool HandleInsertCommand(std::vector<std::string> const& args);
+  bool HandleJoinCommand(std::vector<std::string> const& args);
   bool HandleRemoveAtCommand(std::vector<std::string> const& args);
   bool HandleRemoveItemCommand(std::vector<std::string> const& args);
   bool HandleRemoveDuplicatesCommand(std::vector<std::string> const& args);
+  bool HandleTransformCommand(std::vector<std::string> const& args);
   bool HandleSortCommand(std::vector<std::string> const& args);
+  bool HandleSublistCommand(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,
diff --git a/Source/cmListFileCache.cxx b/Source/cmListFileCache.cxx
index 64e634f44..b468257d0 100644
--- a/Source/cmListFileCache.cxx
+++ b/Source/cmListFileCache.cxx
@@ -13,6 +13,14 @@
 #include <assert.h>
 #include <sstream>
 
+cmCommandContext::cmCommandName& cmCommandContext::cmCommandName::operator=(
+  std::string const& name)
+{
+  this->Original = name;
+  this->Lower = cmSystemTools::LowerCase(name);
+  return *this;
+}
+
 struct cmListFileParser
 {
   cmListFileParser(cmListFile* lf, cmListFileBacktrace const& lfbt,
diff --git a/Source/cmListFileCache.h b/Source/cmListFileCache.h
index 1f9e3740e..70f7166cb 100644
--- a/Source/cmListFileCache.h
+++ b/Source/cmListFileCache.h
@@ -23,11 +23,22 @@ class cmMessenger;
 
 struct cmCommandContext
 {
-  std::string Name;
+  struct cmCommandName
+  {
+    std::string Lower;
+    std::string Original;
+    cmCommandName() {}
+    cmCommandName(std::string const& name) { *this = name; }
+    cmCommandName& operator=(std::string const& name);
+  } Name;
   long Line;
   cmCommandContext()
-    : Name()
-    , Line(0)
+    : Line(0)
+  {
+  }
+  cmCommandContext(const char* name, int line)
+    : Name(name)
+    , Line(line)
   {
   }
 };
@@ -81,7 +92,7 @@ public:
     cmListFileContext lfc;
     lfc.FilePath = fileName;
     lfc.Line = lfcc.Line;
-    lfc.Name = lfcc.Name;
+    lfc.Name = lfcc.Name.Original;
     return lfc;
   }
 };
diff --git a/Source/cmListFileLexer.h b/Source/cmListFileLexer.h
index f243010ad..8962396fd 100644
--- a/Source/cmListFileLexer.h
+++ b/Source/cmListFileLexer.h
@@ -3,7 +3,8 @@
 #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,
diff --git a/Source/cmLoadCommandCommand.cxx b/Source/cmLoadCommandCommand.cxx
index 6bfac172f..cd715188a 100644
--- a/Source/cmLoadCommandCommand.cxx
+++ b/Source/cmLoadCommandCommand.cxx
@@ -18,7 +18,7 @@
 class cmExecutionStatus;
 
 #ifdef __QNX__
-#include <malloc.h> /* for malloc/free on QNX */
+#  include <malloc.h> /* for malloc/free on QNX */
 #endif
 
 extern "C" void TrapsForSignalsCFunction(int sig);
diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx
index e942ff4d9..a3f4a8fe7 100644
--- a/Source/cmLocalGenerator.cxx
+++ b/Source/cmLocalGenerator.cxx
@@ -27,8 +27,8 @@
 #include "cmake.h"
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
-#define CM_LG_ENCODE_OBJECT_NAMES
-#include "cmCryptoHash.h"
+#  define CM_LG_ENCODE_OBJECT_NAMES
+#  include "cmCryptoHash.h"
 #endif
 
 #include "cmsys/RegularExpression.hxx"
@@ -42,8 +42,8 @@
 #include <utility>
 
 #if defined(__HAIKU__)
-#include <FindDirectory.h>
-#include <StorageDefs.h>
+#  include <FindDirectory.h>
+#  include <StorageDefs.h>
 #endif
 
 // List of variables that are replaced when
@@ -202,6 +202,22 @@ void cmLocalGenerator::ComputeObjectMaxPath()
   this->ObjectMaxPathViolations.clear();
 }
 
+void cmLocalGenerator::MoveSystemIncludesToEnd(
+  std::vector<std::string>& includeDirs, const std::string& config,
+  const std::string& lang, const cmGeneratorTarget* target) const
+{
+  if (!target) {
+    return;
+  }
+
+  std::stable_sort(
+    includeDirs.begin(), includeDirs.end(),
+    [&target, &config, &lang](std::string const& a, std::string const& b) {
+      return !target->IsSystemIncludeDirectory(a, config, lang) &&
+        target->IsSystemIncludeDirectory(b, config, lang);
+    });
+}
+
 void cmLocalGenerator::TraceDependencies()
 {
   std::vector<std::string> configs;
@@ -651,7 +667,7 @@ std::string cmLocalGenerator::ConvertToIncludeReference(
 }
 
 std::string cmLocalGenerator::GetIncludeFlags(
-  const std::vector<std::string>& includes, cmGeneratorTarget* target,
+  const std::vector<std::string>& includeDirs, cmGeneratorTarget* target,
   const std::string& lang, bool forceFullPaths, bool forResponseFile,
   const std::string& config)
 {
@@ -659,6 +675,9 @@ std::string cmLocalGenerator::GetIncludeFlags(
     return "";
   }
 
+  std::vector<std::string> includes = includeDirs;
+  this->MoveSystemIncludesToEnd(includes, config, lang, target);
+
   OutputFormat shellFormat = forResponseFile ? RESPONSE : SHELL;
   std::ostringstream includeFlags;
 
@@ -924,6 +943,8 @@ void cmLocalGenerator::GetIncludeDirectories(std::vector<std::string>& dirs,
     }
   }
 
+  this->MoveSystemIncludesToEnd(dirs, config, lang, target);
+
   // Add standard include directories for this language.
   // We do not filter out implicit directories here.
   std::string const standardIncludesVar =
@@ -1541,8 +1562,9 @@ void cmLocalGenerator::AddCompilerRequirementFlag(
       target->Target->GetMakefile()->GetDefinition(option_flag);
     if (!opt) {
       std::ostringstream e;
-      e << "Target \"" << target->GetName() << "\" requires the language "
-                                               "dialect \""
+      e << "Target \"" << target->GetName()
+        << "\" requires the language "
+           "dialect \""
         << lang << standardProp << "\" "
         << (ext ? "(with compiler extensions)" : "")
         << ", but CMake "
@@ -1561,6 +1583,7 @@ void cmLocalGenerator::AddCompilerRequirementFlag(
   static std::map<std::string, std::vector<std::string>> langStdMap;
   if (langStdMap.empty()) {
     // Maintain sorted order, most recent first.
+    langStdMap["CXX"].push_back("20");
     langStdMap["CXX"].push_back("17");
     langStdMap["CXX"].push_back("14");
     langStdMap["CXX"].push_back("11");
diff --git a/Source/cmLocalGenerator.h b/Source/cmLocalGenerator.h
index 533ac56ba..9ba62cc8d 100644
--- a/Source/cmLocalGenerator.h
+++ b/Source/cmLocalGenerator.h
@@ -411,6 +411,10 @@ private:
                                    int targetType);
 
   void ComputeObjectMaxPath();
+  void MoveSystemIncludesToEnd(std::vector<std::string>& includeDirs,
+                               const std::string& config,
+                               const std::string& lang,
+                               cmGeneratorTarget const* target) const;
 };
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
diff --git a/Source/cmLocalNinjaGenerator.cxx b/Source/cmLocalNinjaGenerator.cxx
index 8c889fc03..360f73da5 100644
--- a/Source/cmLocalNinjaGenerator.cxx
+++ b/Source/cmLocalNinjaGenerator.cxx
@@ -10,6 +10,7 @@
 #include <stdio.h>
 #include <utility>
 
+#include "cmCryptoHash.h"
 #include "cmCustomCommand.h"
 #include "cmCustomCommandGenerator.h"
 #include "cmGeneratedFileStream.h"
@@ -24,6 +25,7 @@
 #include "cmStateTypes.h"
 #include "cmSystemTools.h"
 #include "cmake.h"
+#include "cmsys/FStream.hxx"
 
 cmLocalNinjaGenerator::cmLocalNinjaGenerator(cmGlobalGenerator* gg,
                                              cmMakefile* mf)
@@ -74,8 +76,8 @@ void cmLocalNinjaGenerator::Generate()
     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";
     }
   }
 
@@ -195,6 +197,16 @@ void cmLocalNinjaGenerator::WriteNinjaRequiredVersion(std::ostream& os)
       this->GetGlobalNinjaGenerator()->RequiredNinjaVersionForConsolePool();
   }
 
+  // The Ninja generator writes rules which require support for restat
+  // when rebuilding build.ninja manifest (>= 1.8)
+  if (this->GetGlobalNinjaGenerator()->SupportsManifestRestat() &&
+      this->GetCMakeInstance()->DoWriteGlobVerifyTarget() &&
+      !this->GetGlobalNinjaGenerator()->GlobalSettingIsOn(
+        "CMAKE_SUPPRESS_REGENERATION")) {
+    requiredVersion =
+      this->GetGlobalNinjaGenerator()->RequiredNinjaVersionForManifestRestat();
+  }
+
   cmGlobalNinjaGenerator::WriteComment(
     os, "Minimal version of Ninja required by this file");
   os << "ninja_required_version = " << requiredVersion << std::endl
@@ -239,8 +251,7 @@ void cmLocalNinjaGenerator::WriteNinjaFilesInclusion(std::ostream& os)
   cmGlobalNinjaGenerator* ng = this->GetGlobalNinjaGenerator();
   std::string const ninjaRulesFile =
     ng->NinjaOutputPath(cmGlobalNinjaGenerator::NINJA_RULES_FILE);
-  std::string const rulesFilePath =
-    ng->EncodeIdent(ng->EncodePath(ninjaRulesFile), os);
+  std::string const rulesFilePath = ng->EncodePath(ninjaRulesFile);
   cmGlobalNinjaGenerator::WriteInclude(os, rulesFilePath,
                                        "Include rules file.");
   os << "\n";
@@ -286,8 +297,51 @@ void cmLocalNinjaGenerator::AppendCustomCommandDeps(
   }
 }
 
+std::string cmLocalNinjaGenerator::WriteCommandScript(
+  std::vector<std::string> const& cmdLines, std::string const& customStep,
+  cmGeneratorTarget const* target) const
+{
+  std::string scriptPath;
+  if (target) {
+    scriptPath = target->GetSupportDirectory();
+  } else {
+    scriptPath = this->GetCurrentBinaryDirectory();
+    scriptPath += cmake::GetCMakeFilesDirectory();
+  }
+  cmSystemTools::MakeDirectory(scriptPath);
+  scriptPath += '/';
+  scriptPath += customStep;
+#ifdef _WIN32
+  scriptPath += ".bat";
+#else
+  scriptPath += ".sh";
+#endif
+
+  cmsys::ofstream script(scriptPath.c_str());
+
+#ifndef _WIN32
+  script << "set -e\n\n";
+#endif
+
+  for (auto const& i : cmdLines) {
+    std::string cmd = i;
+    // The command line was built assuming it would be written to
+    // the build.ninja file, so it uses '$$' for '$'.  Remove this
+    // for the raw shell script.
+    cmSystemTools::ReplaceString(cmd, "$$", "$");
+#ifdef _WIN32
+    script << cmd << " || exit /b" << '\n';
+#else
+    script << cmd << '\n';
+#endif
+  }
+
+  return scriptPath;
+}
+
 std::string cmLocalNinjaGenerator::BuildCommandLine(
-  const std::vector<std::string>& cmdLines)
+  std::vector<std::string> const& cmdLines, std::string const& customStep,
+  cmGeneratorTarget const* target) const
 {
   // If we have no commands but we need to build a command anyway, use noop.
   // This happens when building a POST_BUILD value for link targets that
@@ -296,6 +350,35 @@ std::string cmLocalNinjaGenerator::BuildCommandLine(
     return cmGlobalNinjaGenerator::SHELL_NOOP;
   }
 
+  // If this is a custom step then we will have no '$VAR' ninja placeholders.
+  // This means we can deal with long command sequences by writing to a script.
+  // Do this if the command lines are on the scale of the OS limit.
+  if (!customStep.empty()) {
+    size_t cmdLinesTotal = 0;
+    for (std::string const& cmd : cmdLines) {
+      cmdLinesTotal += cmd.length() + 6;
+    }
+    if (cmdLinesTotal > cmSystemTools::CalculateCommandLineLengthLimit() / 2) {
+      std::string const scriptPath =
+        this->WriteCommandScript(cmdLines, customStep, target);
+      std::string cmd
+#ifndef _WIN32
+        = "/bin/sh "
+#endif
+        ;
+      cmd += this->ConvertToOutputFormat(
+        this->GetGlobalNinjaGenerator()->ConvertToNinjaPath(scriptPath),
+        cmOutputConverter::SHELL);
+
+      // Add an unused argument based on script content so that Ninja
+      // knows when the command lines change.
+      cmd += " ";
+      cmCryptoHash hash(cmCryptoHash::AlgoSHA256);
+      cmd += hash.HashFile(scriptPath).substr(0, 16);
+      return cmd;
+    }
+  }
+
   std::ostringstream cmd;
   for (std::vector<std::string>::const_iterator li = cmdLines.begin();
        li != cmdLines.end(); ++li)
@@ -382,7 +465,7 @@ void cmLocalNinjaGenerator::WriteCustomCommandBuildStatement(
   }
 
 #if 0
-#error TODO: Once CC in an ExternalProject target must provide the \
+#  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
@@ -406,10 +489,16 @@ void cmLocalNinjaGenerator::WriteCustomCommandBuildStatement(
       "Phony custom command for " + ninjaOutputs[0], ninjaOutputs, ninjaDeps,
       cmNinjaDeps(), orderOnlyDeps, cmNinjaVars());
   } else {
+    std::string customStep = cmSystemTools::GetFilenameName(ninjaOutputs[0]);
+    // Hash full path to make unique.
+    customStep += '-';
+    cmCryptoHash hash(cmCryptoHash::AlgoSHA256);
+    customStep += hash.HashString(ninjaOutputs[0]).substr(0, 7);
+
     this->GetGlobalNinjaGenerator()->WriteCustomCommandBuild(
-      this->BuildCommandLine(cmdLines), this->ConstructComment(ccg),
-      "Custom command for " + ninjaOutputs[0], cc->GetDepfile(),
-      cc->GetUsesTerminal(),
+      this->BuildCommandLine(cmdLines, customStep),
+      this->ConstructComment(ccg), "Custom command for " + ninjaOutputs[0],
+      cc->GetDepfile(), cc->GetUsesTerminal(),
       /*restat*/ !symbolic || !byproducts.empty(), ninjaOutputs, ninjaDeps,
       orderOnlyDeps);
   }
diff --git a/Source/cmLocalNinjaGenerator.h b/Source/cmLocalNinjaGenerator.h
index 95d8a61b8..f772fb0a7 100644
--- a/Source/cmLocalNinjaGenerator.h
+++ b/Source/cmLocalNinjaGenerator.h
@@ -59,7 +59,10 @@ public:
     return this->HomeRelativeOutputPath;
   }
 
-  std::string BuildCommandLine(const std::vector<std::string>& cmdLines);
+  std::string BuildCommandLine(
+    std::vector<std::string> const& cmdLines,
+    std::string const& customStep = std::string(),
+    cmGeneratorTarget const* target = nullptr) const;
 
   void AppendTargetOutputs(cmGeneratorTarget* target, cmNinjaDeps& outputs);
   void AppendTargetDepends(
@@ -98,6 +101,10 @@ private:
 
   std::string MakeCustomLauncher(cmCustomCommandGenerator const& ccg);
 
+  std::string WriteCommandScript(std::vector<std::string> const& cmdLines,
+                                 std::string const& customStep,
+                                 cmGeneratorTarget const* target) const;
+
   std::string HomeRelativeOutputPath;
 
   typedef std::map<cmCustomCommand const*, std::set<cmGeneratorTarget*>>
diff --git a/Source/cmLocalUnixMakefileGenerator3.cxx b/Source/cmLocalUnixMakefileGenerator3.cxx
index ddd8cc4c3..9fd2ddb72 100644
--- a/Source/cmLocalUnixMakefileGenerator3.cxx
+++ b/Source/cmLocalUnixMakefileGenerator3.cxx
@@ -35,8 +35,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
 
 // Escape special characters in Makefile dependency lines
@@ -760,8 +760,17 @@ void cmLocalUnixMakefileGenerator3::WriteSpecialTargetsBottom(
 
   // Write special "cmake_check_build_system" target to run cmake with
   // the --check-build-system flag.
-  {
+  if (!this->GlobalGenerator->GlobalSettingIsOn(
+        "CMAKE_SUPPRESS_REGENERATION")) {
     // Build command to run CMake to check if anything needs regenerating.
+    std::vector<std::string> commands;
+    cmake* cm = this->GlobalGenerator->GetCMakeInstance();
+    if (cm->DoWriteGlobVerifyTarget()) {
+      std::string rescanRule = "$(CMAKE_COMMAND) -P ";
+      rescanRule += this->ConvertToOutputFormat(cm->GetGlobVerifyScript(),
+                                                cmOutputConverter::SHELL);
+      commands.push_back(rescanRule);
+    }
     std::string cmakefileName = cmake::GetCMakeFilesDirectoryPostSlash();
     cmakefileName += "Makefile.cmake";
     std::string runRule =
@@ -772,19 +781,19 @@ void cmLocalUnixMakefileGenerator3::WriteSpecialTargetsBottom(
     runRule += " 0";
 
     std::vector<std::string> no_depends;
-    std::vector<std::string> commands;
     commands.push_back(std::move(runRule));
     if (!this->IsRootMakefile()) {
       this->CreateCDCommand(commands, this->GetBinaryDirectory(),
                             this->GetCurrentBinaryDirectory());
     }
-    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);
+    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);
   }
 }
 
@@ -1513,9 +1522,10 @@ void cmLocalUnixMakefileGenerator3::WriteLocalAllRules(
       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.",
+      this->WriteMakeRule(ruleFileStream,
+                          "Allow only one \"make -f "
+                          "Makefile2\" at a time, but pass "
+                          "parallelism.",
                           ".NOTPARALLEL", no_depends, no_commands, false);
     }
   }
@@ -1580,7 +1590,11 @@ void cmLocalUnixMakefileGenerator3::WriteLocalAllRules(
   std::string recursiveTarget = this->GetCurrentBinaryDirectory();
   recursiveTarget += "/all";
 
-  depends.push_back("cmake_check_build_system");
+  bool regenerate =
+    !this->GlobalGenerator->GlobalSettingIsOn("CMAKE_SUPPRESS_REGENERATION");
+  if (regenerate) {
+    depends.push_back("cmake_check_build_system");
+  }
 
   std::string progressDir = this->GetBinaryDirectory();
   progressDir += cmake::GetCMakeFilesDirectory();
@@ -1643,7 +1657,7 @@ void cmLocalUnixMakefileGenerator3::WriteLocalAllRules(
   if (!noall || cmSystemTools::IsOff(noall)) {
     // Drive the build before installing.
     depends.push_back("all");
-  } else {
+  } else if (regenerate) {
     // At least make sure the build system is up to date.
     depends.push_back("cmake_check_build_system");
   }
@@ -1657,24 +1671,33 @@ void cmLocalUnixMakefileGenerator3::WriteLocalAllRules(
   this->WriteMakeRule(ruleFileStream, "Prepare targets for installation.",
                       "preinstall/fast", depends, commands, true);
 
-  // write the depend rule, really a recompute depends rule
-  depends.clear();
-  commands.clear();
-  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->ConvertToOutputFormat(cmakefileName, cmOutputConverter::SHELL);
-    runRule += " 1";
-    commands.push_back(std::move(runRule));
+  if (regenerate) {
+    // write the depend rule, really a recompute depends rule
+    depends.clear();
+    commands.clear();
+    cmake* cm = this->GlobalGenerator->GetCMakeInstance();
+    if (cm->DoWriteGlobVerifyTarget()) {
+      std::string rescanRule = "$(CMAKE_COMMAND) -P ";
+      rescanRule += this->ConvertToOutputFormat(cm->GetGlobVerifyScript(),
+                                                cmOutputConverter::SHELL);
+      commands.push_back(rescanRule);
+    }
+    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->ConvertToOutputFormat(cmakefileName, cmOutputConverter::SHELL);
+      runRule += " 1";
+      commands.push_back(std::move(runRule));
+    }
+    this->CreateCDCommand(commands, this->GetBinaryDirectory(),
+                          this->GetCurrentBinaryDirectory());
+    this->WriteMakeRule(ruleFileStream, "clear depends", "depend", depends,
+                        commands, true);
   }
-  this->CreateCDCommand(commands, this->GetBinaryDirectory(),
-                        this->GetCurrentBinaryDirectory());
-  this->WriteMakeRule(ruleFileStream, "clear depends", "depend", depends,
-                      commands, true);
 }
 
 void cmLocalUnixMakefileGenerator3::ClearDependencies(cmMakefile* mf,
diff --git a/Source/cmLocalUnixMakefileGenerator3.h b/Source/cmLocalUnixMakefileGenerator3.h
index bc72f1b30..869ef1ee9 100644
--- a/Source/cmLocalUnixMakefileGenerator3.h
+++ b/Source/cmLocalUnixMakefileGenerator3.h
@@ -243,7 +243,7 @@ protected:
                           cmGeneratorTarget* target,
                           const char* filename = nullptr);
 
-  // Helper methods for dependeny updates.
+  // Helper methods for dependency updates.
   bool ScanDependencies(
     const char* targetDir,
     std::map<std::string, cmDepends::DependencyVector>& validDeps);
diff --git a/Source/cmLocalVisualStudio10Generator.cxx b/Source/cmLocalVisualStudio10Generator.cxx
index 2803d4a50..0c2c64eb6 100644
--- a/Source/cmLocalVisualStudio10Generator.cxx
+++ b/Source/cmLocalVisualStudio10Generator.cxx
@@ -62,21 +62,48 @@ cmLocalVisualStudio10Generator::~cmLocalVisualStudio10Generator()
 {
 }
 
+void cmLocalVisualStudio10Generator::GenerateTargetsDepthFirst(
+  cmGeneratorTarget* target, std::vector<cmGeneratorTarget*>& remaining)
+{
+  if (target->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
+    return;
+  }
+  // Find this target in the list of remaining targets.
+  auto it = std::find(remaining.begin(), remaining.end(), target);
+  if (it == remaining.end()) {
+    // This target was already handled.
+    return;
+  }
+  // Remove this target from the list of remaining targets because
+  // we are handling it now.
+  *it = nullptr;
+  auto& deps = this->GlobalGenerator->GetTargetDirectDepends(target);
+  for (auto& d : deps) {
+    // FIXME: Revise CreateSingleVCProj so we do not have to drop `const` here.
+    auto dependee = const_cast<cmGeneratorTarget*>(&*d);
+    GenerateTargetsDepthFirst(dependee, remaining);
+    // Take the union of visited source files of custom commands
+    auto visited = GetSourcesVisited(dependee);
+    GetSourcesVisited(target).insert(visited.begin(), visited.end());
+  }
+  if (static_cast<cmGlobalVisualStudioGenerator*>(this->GlobalGenerator)
+        ->TargetIsFortranOnly(target)) {
+    this->CreateSingleVCProj(target->GetName(), target);
+  } else {
+    cmVisualStudio10TargetGenerator tg(
+      target,
+      static_cast<cmGlobalVisualStudio10Generator*>(
+        this->GetGlobalGenerator()));
+    tg.Generate();
+  }
+}
+
 void cmLocalVisualStudio10Generator::Generate()
 {
-  const std::vector<cmGeneratorTarget*>& tgts = this->GetGeneratorTargets();
-  for (cmGeneratorTarget* l : tgts) {
-    if (l->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
-      continue;
-    }
-    if (static_cast<cmGlobalVisualStudioGenerator*>(this->GlobalGenerator)
-          ->TargetIsFortranOnly(l)) {
-      this->CreateSingleVCProj(l->GetName(), l);
-    } else {
-      cmVisualStudio10TargetGenerator tg(
-        l, static_cast<cmGlobalVisualStudio10Generator*>(
-             this->GetGlobalGenerator()));
-      tg.Generate();
+  std::vector<cmGeneratorTarget*> remaining = this->GetGeneratorTargets();
+  for (auto& t : remaining) {
+    if (t) {
+      GenerateTargetsDepthFirst(t, remaining);
     }
   }
   this->WriteStampFiles();
diff --git a/Source/cmLocalVisualStudio10Generator.h b/Source/cmLocalVisualStudio10Generator.h
index bcdc30709..a4150b94d 100644
--- a/Source/cmLocalVisualStudio10Generator.h
+++ b/Source/cmLocalVisualStudio10Generator.h
@@ -33,10 +33,19 @@ public:
   void ReadAndStoreExternalGUID(const std::string& name,
                                 const char* path) override;
 
+  std::set<cmSourceFile const*>& GetSourcesVisited(cmGeneratorTarget* target)
+  {
+    return SourcesVisited[target];
+  };
+
 protected:
   const char* ReportErrorLabel() const override;
   bool CustomCommandUseLocal() const override { return true; }
 
 private:
+  void GenerateTargetsDepthFirst(cmGeneratorTarget* target,
+                                 std::vector<cmGeneratorTarget*>& remaining);
+
+  std::map<cmGeneratorTarget*, std::set<cmSourceFile const*>> SourcesVisited;
 };
 #endif
diff --git a/Source/cmLocalVisualStudio7Generator.cxx b/Source/cmLocalVisualStudio7Generator.cxx
index 13503ad8c..346028920 100644
--- a/Source/cmLocalVisualStudio7Generator.cxx
+++ b/Source/cmLocalVisualStudio7Generator.cxx
@@ -160,10 +160,21 @@ void cmLocalVisualStudio7Generator::WriteStampFiles()
   depName += ".depend";
   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) {
-    depFile << *lf << std::endl;
+
+  std::vector<std::string> listFiles(this->Makefile->GetListFiles());
+  cmake* cm = this->GlobalGenerator->GetCMakeInstance();
+  if (cm->DoWriteGlobVerifyTarget()) {
+    listFiles.push_back(cm->GetGlobVerifyStamp());
+  }
+
+  // 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());
+
+  for (const std::string& lf : listFiles) {
+    depFile << lf << "\n";
   }
 }
 
@@ -210,7 +221,8 @@ void cmLocalVisualStudio7Generator::CreateSingleVCProj(
 
 cmSourceFile* cmLocalVisualStudio7Generator::CreateVCProjBuildRule()
 {
-  if (this->Makefile->IsOn("CMAKE_SUPPRESS_REGENERATION")) {
+  if (this->GlobalGenerator->GlobalSettingIsOn(
+        "CMAKE_SUPPRESS_REGENERATION")) {
     return nullptr;
   }
 
@@ -227,6 +239,18 @@ cmSourceFile* cmLocalVisualStudio7Generator::CreateVCProjBuildRule()
     return nullptr;
   }
 
+  std::vector<std::string> listFiles = this->Makefile->GetListFiles();
+  cmake* cm = this->GlobalGenerator->GetCMakeInstance();
+  if (cm->DoWriteGlobVerifyTarget()) {
+    listFiles.push_back(cm->GetGlobVerifyStamp());
+  }
+
+  // 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());
+
   std::string stampName = this->GetCurrentBinaryDirectory();
   stampName += "/";
   stampName += cmake::GetCMakeFilesDirectoryPostSlash();
@@ -244,17 +268,14 @@ cmSourceFile* cmLocalVisualStudio7Generator::CreateVCProjBuildRule()
   commandLine.push_back(args);
   commandLine.push_back("--check-stamp-file");
   commandLine.push_back(stampName);
-
-  std::vector<std::string> const& listFiles = this->Makefile->GetListFiles();
-
   cmCustomCommandLines commandLines;
   commandLines.push_back(commandLine);
   const char* no_working_directory = 0;
   std::string fullpathStampName =
     cmSystemTools::CollapseFullPath(stampName.c_str());
   this->Makefile->AddCustomCommandToOutput(
-    fullpathStampName.c_str(), listFiles, makefileIn.c_str(), commandLines,
-    comment.c_str(), no_working_directory, true, false);
+    fullpathStampName, listFiles, makefileIn, commandLines, comment.c_str(),
+    no_working_directory, true, false);
   if (cmSourceFile* file = this->Makefile->GetSource(makefileIn.c_str())) {
     // Finalize the source file path now since we're adding this after
     // the generator validated all project-named sources.
@@ -791,11 +812,9 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(
          << "\\$(ConfigurationName)\"\n";
   }
   targetOptions.OutputAdditionalIncludeDirectories(
-    fout, "\t\t\t\t", "\n",
-    this->FortranProject ? "Fortran" : langForClCompile);
-  targetOptions.OutputFlagMap(fout, "\t\t\t\t");
-  targetOptions.OutputPreprocessorDefinitions(fout, "\t\t\t\t", "\n",
-                                              langForClCompile);
+    fout, 4, this->FortranProject ? "Fortran" : langForClCompile);
+  targetOptions.OutputFlagMap(fout, 4);
+  targetOptions.OutputPreprocessorDefinitions(fout, 4, langForClCompile);
   fout << "\t\t\t\tObjectFile=\"$(IntDir)\\\"\n";
   if (target->GetType() <= cmStateEnums::OBJECT_LIBRARY) {
     // Specify the compiler program database file if configured.
@@ -814,12 +833,10 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(
       "\t\t\t\tName=\"MASM\"\n"
       ;
     /* clang-format on */
-    targetOptions.OutputAdditionalIncludeDirectories(fout, "\t\t\t\t", "\n",
-                                                     "ASM_MASM");
+    targetOptions.OutputAdditionalIncludeDirectories(fout, 4, "ASM_MASM");
     // Use same preprocessor definitions as VCCLCompilerTool.
-    targetOptions.OutputPreprocessorDefinitions(fout, "\t\t\t\t", "\n",
-                                                "ASM_MASM");
-    masmOptions.OutputFlagMap(fout, "\t\t\t\t");
+    targetOptions.OutputPreprocessorDefinitions(fout, 4, "ASM_MASM");
+    masmOptions.OutputFlagMap(fout, 4);
     /* clang-format off */
     fout <<
       "\t\t\t\tObjectFile=\"$(IntDir)\\\"\n"
@@ -836,18 +853,16 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(
     tool = "VFResourceCompilerTool";
   }
   fout << "\t\t\t<Tool\n\t\t\t\tName=\"" << tool << "\"\n";
-  targetOptions.OutputAdditionalIncludeDirectories(fout, "\n\t\t\t\t", "",
-                                                   "RC");
+  targetOptions.OutputAdditionalIncludeDirectories(fout, 4, "RC");
   // add the -D flags to the RC tool
-  targetOptions.OutputPreprocessorDefinitions(fout, "\n\t\t\t\t", "", "RC");
-  fout << "/>\n";
+  targetOptions.OutputPreprocessorDefinitions(fout, 4, "RC");
+  fout << "\t\t\t/>\n";
   tool = "VCMIDLTool";
   if (this->FortranProject) {
     tool = "VFMIDLTool";
   }
   fout << "\t\t\t<Tool\n\t\t\t\tName=\"" << tool << "\"\n";
-  targetOptions.OutputAdditionalIncludeDirectories(fout, "\n\t\t\t\t", "",
-                                                   "MIDL");
+  targetOptions.OutputAdditionalIncludeDirectories(fout, 4, "MIDL");
   fout << "\t\t\t\tMkTypLibCompatible=\"false\"\n";
   if (gg->GetPlatformName() == "x64") {
     fout << "\t\t\t\tTargetEnvironment=\"3\"\n";
@@ -1072,7 +1087,7 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(
       fout << "\t\t\t\tOutputFile=\""
            << this->ConvertToXMLOutputPathSingle(temp.c_str()) << "\"\n";
       this->WriteTargetVersionAttribute(fout, target);
-      linkOptions.OutputFlagMap(fout, "\t\t\t\t");
+      linkOptions.OutputFlagMap(fout, 4);
       fout << "\t\t\t\tAdditionalLibraryDirectories=\"";
       this->OutputLibraryDirectories(fout, cli.GetDirectories());
       fout << "\"\n";
@@ -1157,7 +1172,7 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(
       fout << "\t\t\t\tOutputFile=\""
            << this->ConvertToXMLOutputPathSingle(temp.c_str()) << "\"\n";
       this->WriteTargetVersionAttribute(fout, target);
-      linkOptions.OutputFlagMap(fout, "\t\t\t\t");
+      linkOptions.OutputFlagMap(fout, 4);
       fout << "\t\t\t\tAdditionalLibraryDirectories=\"";
       this->OutputLibraryDirectories(fout, cli.GetDirectories());
       fout << "\"\n";
@@ -1688,18 +1703,17 @@ bool cmLocalVisualStudio7Generator::WriteGroup(
             }
             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.AddDefines(fc.CompileDefs);
+            fileOptions.AddDefines(fc.CompileDefsConfig);
             // validate source level include directories
             std::vector<std::string> includes;
             this->AppendIncludeDirectories(includes, fc.IncludeDirs, **sf);
             fileOptions.AddIncludes(includes);
-            fileOptions.OutputFlagMap(fout, "\t\t\t\t\t");
+            fileOptions.OutputFlagMap(fout, 5);
             fileOptions.OutputAdditionalIncludeDirectories(
-              fout, "\t\t\t\t\t", "\n",
+              fout, 5,
               ppLang == "CXX" && this->FortranProject ? "Fortran" : ppLang);
-            fileOptions.OutputPreprocessorDefinitions(fout, "\t\t\t\t\t", "\n",
-                                                      ppLang);
+            fileOptions.OutputPreprocessorDefinitions(fout, 5, ppLang);
           }
           if (!fc.AdditionalDeps.empty()) {
             fout << "\t\t\t\t\tAdditionalDependencies=\"" << fc.AdditionalDeps
@@ -2075,6 +2089,19 @@ std::string cmLocalVisualStudio7Generator::ConvertToXMLOutputPathSingle(
   return ret;
 }
 
+void cmVS7GeneratorOptions::OutputFlag(std::ostream& fout, int indent,
+                                       const char* flag,
+                                       const std::string& content)
+{
+  fout.fill('\t');
+  fout.width(indent);
+  // write an empty string to get the fill level indent to print
+  fout << "";
+  fout << flag << "=\"";
+  fout << cmLocalVisualStudio7GeneratorEscapeForXML(content);
+  fout << "\"\n";
+}
+
 // This class is used to parse an existing vs 7 project
 // and extract the GUID
 class cmVS7XMLParser : public cmXMLParser
diff --git a/Source/cmLocalVisualStudio7Generator.h b/Source/cmLocalVisualStudio7Generator.h
index 02e6931d3..b093e6fc9 100644
--- a/Source/cmLocalVisualStudio7Generator.h
+++ b/Source/cmLocalVisualStudio7Generator.h
@@ -21,6 +21,19 @@ class cmMakefile;
 class cmSourceFile;
 class cmSourceGroup;
 
+class cmVS7GeneratorOptions : public cmVisualStudioGeneratorOptions
+{
+public:
+  cmVS7GeneratorOptions(cmLocalVisualStudioGenerator* lg, Tool tool,
+                        cmVS7FlagTable const* table = nullptr,
+                        cmVS7FlagTable const* extraTable = nullptr)
+    : cmVisualStudioGeneratorOptions(lg, tool, table, extraTable)
+  {
+  }
+  void OutputFlag(std::ostream& fout, int indent, const char* tag,
+                  const std::string& content) override;
+};
+
 /** \class cmLocalVisualStudio7Generator
  * \brief Write Visual Studio .NET project files.
  *
@@ -70,7 +83,7 @@ protected:
   void CreateSingleVCProj(const std::string& lname, cmGeneratorTarget* tgt);
 
 private:
-  typedef cmVisualStudioGeneratorOptions Options;
+  typedef cmVS7GeneratorOptions Options;
   typedef cmLocalVisualStudio7GeneratorFCInfo FCInfo;
   std::string GetBuildTypeLinkerFlags(std::string rootLinkerFlags,
                                       const std::string& configName);
diff --git a/Source/cmMSVC60LinkLineComputer.cxx b/Source/cmMSVC60LinkLineComputer.cxx
index 5298d1a79..74c94351c 100644
--- a/Source/cmMSVC60LinkLineComputer.cxx
+++ b/Source/cmMSVC60LinkLineComputer.cxx
@@ -4,7 +4,7 @@
 #include "cmMSVC60LinkLineComputer.h"
 
 #if defined(_WIN32) && !defined(__CYGWIN__)
-#include "cmSystemTools.h"
+#  include "cmSystemTools.h"
 #endif
 
 class cmOutputConverter;
diff --git a/Source/cmMachO.h b/Source/cmMachO.h
index aa17c6a77..5886d7626 100644
--- a/Source/cmMachO.h
+++ b/Source/cmMachO.h
@@ -9,7 +9,7 @@
 #include <string>
 
 #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 07943e344..23d93a381 100644
--- a/Source/cmMacroCommand.cxx
+++ b/Source/cmMacroCommand.cxx
@@ -93,7 +93,7 @@ bool cmMacroHelperCommand::InvokeInitialPass(
   argVs.reserve(expandedArgs.size());
   char argvName[60];
   for (unsigned int j = 0; j < expandedArgs.size(); ++j) {
-    sprintf(argvName, "${ARGV%i}", j);
+    sprintf(argvName, "${ARGV%u}", j);
     argVs.push_back(argvName);
   }
   // Invoke all the functions that were collected in the block.
@@ -161,9 +161,9 @@ bool cmMacroFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff,
 {
   // 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 (lff.Name.Lower == "macro") {
     this->Depth++;
-  } else if (!cmSystemTools::Strucmp(lff.Name.c_str(), "endmacro")) {
+  } else if (lff.Name.Lower == "endmacro") {
     // if this is the endmacro for this macro then execute
     if (!this->Depth) {
       mf.AppendProperty("MACROS", this->Args[0].c_str());
@@ -191,7 +191,7 @@ bool cmMacroFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff,
 bool cmMacroFunctionBlocker::ShouldRemove(const cmListFileFunction& lff,
                                           cmMakefile& mf)
 {
-  if (!cmSystemTools::Strucmp(lff.Name.c_str(), "endmacro")) {
+  if (lff.Name.Lower == "endmacro") {
     std::vector<std::string> expandedArguments;
     mf.ExpandArguments(lff.Arguments, expandedArguments,
                        this->GetStartingContext().FilePath.c_str());
diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx
index 604ca2ca5..3c7a4cf2b 100644
--- a/Source/cmMakefile.cxx
+++ b/Source/cmMakefile.cxx
@@ -6,12 +6,12 @@
 #include "cmsys/RegularExpression.hxx"
 #include <algorithm>
 #include <assert.h>
+#include <cstring>
 #include <ctype.h>
 #include <iterator>
 #include <memory> // IWYU pragma: keep
 #include <sstream>
 #include <stdlib.h>
-#include <string.h>
 #include <utility>
 
 #include "cmAlgorithms.h"
@@ -43,7 +43,7 @@
 #include "cmake.h"
 
 #ifdef CMAKE_BUILD_WITH_CMAKE
-#include "cmVariableWatch.h"
+#  include "cmVariableWatch.h"
 #endif
 
 class cmMessenger;
@@ -158,6 +158,32 @@ bool cmMakefile::CheckCMP0037(std::string const& targetName,
   return true;
 }
 
+void cmMakefile::MaybeWarnCMP0074(std::string const& pkg)
+{
+  // Warn if a <pkg>_ROOT variable we may use is set.
+  std::string const varName = pkg + "_ROOT";
+  const char* var = this->GetDefinition(varName);
+  std::string env;
+  cmSystemTools::GetEnv(varName, env);
+
+  bool const haveVar = var && *var;
+  bool const haveEnv = !env.empty();
+  if ((haveVar || haveEnv) && this->WarnedCMP0074.insert(varName).second) {
+    std::ostringstream w;
+    w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0074) << "\n";
+    if (haveVar) {
+      w << "CMake variable " << varName << " is set to:\n"
+        << "  " << var << "\n";
+    }
+    if (haveEnv) {
+      w << "Environment variable " << varName << " is set to:\n"
+        << "  " << env << "\n";
+    }
+    w << "For compatibility, CMake is ignoring the variable.";
+    this->IssueMessage(cmake::AUTHOR_WARNING, w.str());
+  }
+}
+
 cmStringRange cmMakefile::GetIncludeDirectoriesEntries() const
 {
   return this->StateSnapshot.GetDirectory().GetIncludeDirectoriesEntries();
@@ -198,7 +224,7 @@ cmListFileBacktrace cmMakefile::GetBacktrace() const
 cmListFileBacktrace cmMakefile::GetBacktrace(cmCommandContext const& cc) const
 {
   cmListFileContext lfc;
-  lfc.Name = cc.Name;
+  lfc.Name = cc.Name.Original;
   lfc.Line = cc.Line;
   lfc.FilePath = this->StateSnapshot.GetExecutionListFile();
   return this->Backtrace.Push(lfc);
@@ -239,7 +265,7 @@ void cmMakefile::PrintCommandTrace(const cmListFileFunction& lff) const
 
   std::ostringstream msg;
   msg << full_path << "(" << lff.Line << "):  ";
-  msg << lff.Name << "(";
+  msg << lff.Name.Original << "(";
   bool expand = this->GetCMakeInstance()->GetTraceExpand();
   std::string temp;
   for (cmListFileArgument const& arg : lff.Arguments) {
@@ -291,14 +317,13 @@ bool cmMakefile::ExecuteCommand(const cmListFileFunction& lff,
     return result;
   }
 
-  std::string name = lff.Name;
-
   // Place this call on the call stack.
   cmMakefileCall stack_manager(this, lff, status);
   static_cast<void>(stack_manager);
 
   // Lookup the command prototype.
-  if (cmCommand* proto = this->GetState()->GetCommand(name)) {
+  if (cmCommand* proto =
+        this->GetState()->GetCommandByExactName(lff.Name.Lower)) {
     // Clone the prototype.
     std::unique_ptr<cmCommand> pcmd(proto->Clone());
     pcmd->SetMakefile(this);
@@ -315,7 +340,8 @@ bool cmMakefile::ExecuteCommand(const cmListFileFunction& lff,
       if (!invokeSucceeded || hadNestedError) {
         if (!hadNestedError) {
           // The command invocation requested that we report an error.
-          std::string const error = name + " " + pcmd->GetError();
+          std::string const error =
+            std::string(lff.Name.Original) + " " + pcmd->GetError();
           this->IssueMessage(cmake::FATAL_ERROR, error);
         }
         result = false;
@@ -330,7 +356,7 @@ bool cmMakefile::ExecuteCommand(const cmListFileFunction& lff,
   } else {
     if (!cmSystemTools::GetFatalErrorOccured()) {
       std::string error = "Unknown CMake command \"";
-      error += lff.Name;
+      error += lff.Name.Original;
       error += "\".";
       this->IssueMessage(cmake::FATAL_ERROR, error);
       result = false;
@@ -1104,6 +1130,17 @@ cmTarget* cmMakefile::AddUtilityCommand(
   return target;
 }
 
+static void s_AddDefineFlag(std::string const& flag, std::string& dflags)
+{
+  // remove any \n\r
+  std::string::size_type initSize = dflags.size();
+  dflags += ' ';
+  dflags += flag;
+  std::string::iterator flagStart = dflags.begin() + initSize + 1;
+  std::replace(flagStart, dflags.end(), '\n', ' ');
+  std::replace(flagStart, dflags.end(), '\r', ' ');
+}
+
 void cmMakefile::AddDefineFlag(std::string const& flag)
 {
   if (flag.empty()) {
@@ -1111,7 +1148,7 @@ void cmMakefile::AddDefineFlag(std::string const& flag)
   }
 
   // Update the string used for the old DEFINITIONS property.
-  this->AddDefineFlag(flag, this->DefineFlagsOrig);
+  s_AddDefineFlag(flag, this->DefineFlagsOrig);
 
   // If this is really a definition, update COMPILE_DEFINITIONS.
   if (this->ParseDefineFlag(flag, false)) {
@@ -1119,17 +1156,24 @@ void cmMakefile::AddDefineFlag(std::string const& flag)
   }
 
   // Add this flag that does not look like a definition.
-  this->AddDefineFlag(flag, this->DefineFlags);
+  s_AddDefineFlag(flag, this->DefineFlags);
 }
 
-void cmMakefile::AddDefineFlag(std::string const& flag, std::string& dflags)
+static void s_RemoveDefineFlag(std::string const& flag, std::string& dflags)
 {
-  // remove any \n\r
-  std::string::size_type initSize = dflags.size();
-  dflags += std::string(" ") + flag;
-  std::string::iterator flagStart = dflags.begin() + initSize + 1;
-  std::replace(flagStart, dflags.end(), '\n', ' ');
-  std::replace(flagStart, dflags.end(), '\r', ' ');
+  std::string::size_type const len = flag.length();
+  // 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)) {
+    std::string::size_type rpos = lpos + len;
+    if ((lpos <= 0 || isspace(dflags[lpos - 1])) &&
+        (rpos >= dflags.size() || isspace(dflags[rpos]))) {
+      dflags.erase(lpos, len);
+    } else {
+      ++lpos;
+    }
+  }
 }
 
 void cmMakefile::RemoveDefineFlag(std::string const& flag)
@@ -1138,9 +1182,9 @@ void cmMakefile::RemoveDefineFlag(std::string const& flag)
   if (flag.empty()) {
     return;
   }
-  std::string::size_type const len = flag.length();
+
   // Update the string used for the old DEFINITIONS property.
-  this->RemoveDefineFlag(flag, len, this->DefineFlagsOrig);
+  s_RemoveDefineFlag(flag, this->DefineFlagsOrig);
 
   // If this is really a definition, update COMPILE_DEFINITIONS.
   if (this->ParseDefineFlag(flag, true)) {
@@ -1148,25 +1192,12 @@ void cmMakefile::RemoveDefineFlag(std::string const& flag)
   }
 
   // Remove this flag that does not look like a definition.
-  this->RemoveDefineFlag(flag, len, this->DefineFlags);
+  s_RemoveDefineFlag(flag, this->DefineFlags);
 }
 
-void cmMakefile::RemoveDefineFlag(std::string const& flag,
-                                  std::string::size_type len,
-                                  std::string& dflags)
+void cmMakefile::AddCompileDefinition(std::string const& option)
 {
-  // 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)) {
-    std::string::size_type rpos = lpos + len;
-    if ((lpos <= 0 || isspace(dflags[lpos - 1])) &&
-        (rpos >= dflags.size() || isspace(dflags[rpos]))) {
-      dflags.erase(lpos, len);
-    } else {
-      ++lpos;
-    }
-  }
+  this->AppendProperty("COMPILE_DEFINITIONS", option.c_str());
 }
 
 void cmMakefile::AddCompileOption(std::string const& option)
@@ -1423,7 +1454,7 @@ void cmMakefile::Configure()
     bool hasVersion = false;
     // search for the right policy command
     for (cmListFileFunction const& func : listFile.Functions) {
-      if (cmSystemTools::LowerCase(func.Name) == "cmake_minimum_required") {
+      if (func.Name.Lower == "cmake_minimum_required") {
         hasVersion = true;
         break;
       }
@@ -1450,8 +1481,7 @@ void cmMakefile::Configure()
         allowedCommands.insert("message");
         isProblem = false;
         for (cmListFileFunction const& func : listFile.Functions) {
-          std::string name = cmSystemTools::LowerCase(func.Name);
-          if (allowedCommands.find(name) == allowedCommands.end()) {
+          if (allowedCommands.find(func.Name.Lower) == allowedCommands.end()) {
             isProblem = true;
             break;
           }
@@ -1464,13 +1494,13 @@ void cmMakefile::Configure()
         this->SetCheckCMP0000(true);
 
         // Implicitly set the version for the user.
-        this->SetPolicyVersion("2.4");
+        this->SetPolicyVersion("2.4", std::string());
       }
     }
     bool hasProject = false;
     // search for a project command
     for (cmListFileFunction const& func : listFile.Functions) {
-      if (cmSystemTools::LowerCase(func.Name) == "project") {
+      if (func.Name.Lower == "project") {
         hasProject = true;
         break;
       }
@@ -1478,7 +1508,7 @@ void cmMakefile::Configure()
     // if no project command is found, add one
     if (!hasProject) {
       cmListFileFunction project;
-      project.Name = "PROJECT";
+      project.Name.Lower = "project";
       project.Arguments.emplace_back("Project", cmListFileArgument::Unquoted,
                                      0);
       listFile.Functions.insert(listFile.Functions.begin(), project);
@@ -1675,8 +1705,9 @@ void cmMakefile::AddCacheDefinition(const std::string& name, const char* value,
   // must be outside the following if() to keep it alive long enough
   std::string nvalue;
 
-  if (existingValue && (this->GetState()->GetCacheEntryType(name) ==
-                        cmStateEnums::UNINITIALIZED)) {
+  if (existingValue &&
+      (this->GetState()->GetCacheEntryType(name) ==
+       cmStateEnums::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) {
@@ -1810,12 +1841,10 @@ void cmMakefile::AddGlobalLinkInformation(cmTarget& target)
     std::vector<std::string> linkDirs;
     cmSystemTools::ExpandListArgument(linkDirsProp, linkDirs);
 
-    for (std::string const& linkDir : linkDirs) {
-      std::string newdir = linkDir;
-      // remove trailing slashes
-      if (*linkDir.rbegin() == '/') {
-        newdir = linkDir.substr(0, linkDir.size() - 1);
-      }
+    for (std::string& linkDir : linkDirs) {
+      // Sanitize the path the same way the link_directories command does
+      // in case projects set the LINK_DIRECTORIES property directly.
+      cmSystemTools::ConvertToUnixSlashes(linkDir);
       target.AddLinkDirectory(linkDir);
     }
   }
@@ -1867,7 +1896,7 @@ cmTarget* cmMakefile::AddLibrary(const std::string& lname,
   // Clear its dependencies. Otherwise, dependencies might persist
   // over changes in CMakeLists.txt, making the information stale and
   // hence useless.
-  target->ClearDependencyInformation(*this, lname);
+  target->ClearDependencyInformation(*this);
   if (excludeFromAll) {
     target->SetProperty("EXCLUDE_FROM_ALL", "TRUE");
   }
@@ -2346,10 +2375,11 @@ const char* cmMakefile::GetDefinition(const std::string& name) const
 #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);
+    bool const watch_function_executed =
+      vv->VariableAccessed(name,
+                           def ? cmVariableWatch::VARIABLE_READ_ACCESS
+                               : cmVariableWatch::UNKNOWN_VARIABLE_READ_ACCESS,
+                           def, this);
 
     if (watch_function_executed) {
       // A callback was executed and may have caused re-allocation of the
@@ -2383,12 +2413,13 @@ std::vector<std::string> cmMakefile::GetDefinitions() const
   return res;
 }
 
-const char* cmMakefile::ExpandVariablesInString(std::string& source) const
+const std::string& cmMakefile::ExpandVariablesInString(
+  std::string& source) const
 {
   return this->ExpandVariablesInString(source, false, false);
 }
 
-const char* cmMakefile::ExpandVariablesInString(
+const std::string& cmMakefile::ExpandVariablesInString(
   std::string& source, bool escapeQuotes, bool noEscapes, bool atOnly,
   const char* filename, long line, bool removeEmpty, bool replaceAt) const
 {
@@ -2404,7 +2435,7 @@ const char* cmMakefile::ExpandVariablesInString(
     this->IssueMessage(cmake::INTERNAL_ERROR,
                        "ExpandVariablesInString @ONLY called "
                        "on something with escapes.");
-    return source.c_str();
+    return source;
   }
 
   // Variables used in the WARN case.
@@ -2486,7 +2517,7 @@ const char* cmMakefile::ExpandVariablesInString(
     this->IssueMessage(cmake::AUTHOR_WARNING, msg);
   }
 
-  return source.c_str();
+  return source;
 }
 
 cmake::MessageType cmMakefile::ExpandVariablesInStringOld(
@@ -2601,7 +2632,12 @@ cmake::MessageType cmMakefile::ExpandVariablesInStringOld(
   return mtype;
 }
 
-typedef enum { NORMAL, ENVIRONMENT, CACHE } t_domain;
+typedef enum
+{
+  NORMAL,
+  ENVIRONMENT,
+  CACHE
+} t_domain;
 struct t_lookup
 {
   t_lookup()
@@ -2790,9 +2826,11 @@ cmake::MessageType cmMakefile::ExpandVariablesInStringNew(
           const char* nextAt = strchr(in + 1, '@');
           if (nextAt && nextAt != in + 1 &&
               nextAt ==
-                in + 1 + strspn(in + 1, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-                                        "abcdefghijklmnopqrstuvwxyz"
-                                        "0123456789/_.+-")) {
+                in + 1 +
+                  strspn(in + 1,
+                         "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                         "abcdefghijklmnopqrstuvwxyz"
+                         "0123456789/_.+-")) {
             std::string variable(in + 1, nextAt - in - 1);
             std::string varresult = this->GetSafeDefinition(variable);
             if (escapeQuotes) {
@@ -3140,6 +3178,14 @@ void cmMakefile::SetArgcArgv(const std::vector<std::string>& args)
 cmSourceFile* cmMakefile::GetSource(const std::string& sourceName,
                                     cmSourceFileLocationKind kind) const
 {
+  // First check "Known" paths (avoids the creation of cmSourceFileLocation)
+  if (kind == cmSourceFileLocationKind::Known) {
+    auto sfsi = this->KnownFileSearchIndex.find(sourceName);
+    if (sfsi != this->KnownFileSearchIndex.end()) {
+      return sfsi->second;
+    }
+  }
+
   cmSourceFileLocation sfl(this, sourceName, kind);
   auto name = this->GetCMakeInstance()->StripExtension(sfl.GetName());
 #if defined(_WIN32) || defined(__APPLE__)
@@ -3172,6 +3218,10 @@ cmSourceFile* cmMakefile::CreateSource(const std::string& sourceName,
   name = cmSystemTools::LowerCase(name);
 #endif
   this->SourceFileSearchIndex[name].push_back(sf);
+  // for "Known" paths add direct lookup (used for faster lookup in GetSource)
+  if (kind == cmSourceFileLocationKind::Known) {
+    this->KnownFileSearchIndex[sourceName] = sf;
+  }
 
   return sf;
 }
@@ -3227,7 +3277,7 @@ 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::string& targetName, bool fast, int jobs,
                            const std::vector<std::string>* cmakeArgs,
                            std::string& output)
 {
@@ -3240,6 +3290,14 @@ int cmMakefile::TryCompile(const std::string& srcdir,
   // change to the tests directory and run cmake
   // use the cmake object instead of calling cmake
   cmWorkingDirectory workdir(bindir);
+  if (workdir.Failed()) {
+    this->IssueMessage(cmake::FATAL_ERROR,
+                       "Failed to set working directory to " + bindir + " : " +
+                         std::strerror(workdir.GetLastResult()));
+    cmSystemTools::SetFatalErrorOccured();
+    this->IsSourceFileTryCompile = false;
+    return 1;
+  }
 
   // make sure the same generator is used
   // use this program as the cmake to be run, it should not
@@ -3249,7 +3307,8 @@ int cmMakefile::TryCompile(const std::string& srcdir,
   cmGlobalGenerator* gg =
     cm.CreateGlobalGenerator(this->GetGlobalGenerator()->GetName());
   if (!gg) {
-    this->IssueMessage(cmake::INTERNAL_ERROR, "Global generator '" +
+    this->IssueMessage(cmake::INTERNAL_ERROR,
+                       "Global generator '" +
                          this->GetGlobalGenerator()->GetName() +
                          "' could not be created.");
     cmSystemTools::SetFatalErrorOccured();
@@ -3331,7 +3390,7 @@ int cmMakefile::TryCompile(const std::string& srcdir,
 
   // finally call the generator to actually build the resulting project
   int ret = this->GetGlobalGenerator()->TryCompile(
-    srcdir, bindir, projectName, targetName, fast, output, this);
+    jobs, srcdir, bindir, projectName, targetName, fast, output, this);
 
   this->IsSourceFileTryCompile = false;
   return ret;
@@ -3643,6 +3702,20 @@ void cmMakefile::AppendProperty(const std::string& prop, const char* value,
 
 const char* cmMakefile::GetProperty(const std::string& prop) const
 {
+  // Check for computed properties.
+  static std::string output;
+  if (prop == "TESTS") {
+    std::vector<std::string> keys;
+    // get list of keys
+    std::transform(this->Tests.begin(), this->Tests.end(),
+                   std::back_inserter(keys),
+                   [](decltype(this->Tests)::value_type const& pair) {
+                     return pair.first;
+                   });
+    output = cmJoin(keys, ";");
+    return output.c_str();
+  }
+
   return this->StateSnapshot.GetDirectory().GetProperty(prop);
 }
 
@@ -3782,7 +3855,16 @@ void cmMakefile::RaiseScope(const std::string& var, const char* varDef)
     std::ostringstream m;
     m << "Cannot set \"" << var << "\": current scope has no parent.";
     this->IssueMessage(cmake::AUTHOR_WARNING, m.str());
+    return;
   }
+
+#ifdef CMAKE_BUILD_WITH_CMAKE
+  cmVariableWatch* vv = this->GetVariableWatch();
+  if (vv) {
+    vv->VariableAccessed(var, cmVariableWatch::VARIABLE_MODIFIED_ACCESS,
+                         varDef, this);
+  }
+#endif
 }
 
 cmTarget* cmMakefile::AddImportedTarget(const std::string& name,
@@ -3791,8 +3873,9 @@ cmTarget* cmMakefile::AddImportedTarget(const std::string& name,
 {
   // Create the target.
   std::unique_ptr<cmTarget> target(
-    new cmTarget(name, type, global ? cmTarget::VisibilityImportedGlobally
-                                    : cmTarget::VisibilityImported,
+    new cmTarget(name, type,
+                 global ? cmTarget::VisibilityImportedGlobally
+                        : cmTarget::VisibilityImported,
                  this));
 
   // Add to the set of available imported targets.
@@ -4023,10 +4106,10 @@ 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,
+                                                     bool parent_scope) const
 {
-  return this->StateSnapshot.GetPolicy(id);
+  return this->StateSnapshot.GetPolicy(id, parent_scope);
 }
 
 bool cmMakefile::PolicyOptionalWarningEnabled(std::string const& var)
@@ -4117,9 +4200,10 @@ void cmMakefile::PopSnapshot(bool reportError)
   assert(this->StateSnapshot.IsValid());
 }
 
-bool cmMakefile::SetPolicyVersion(const char* version)
+bool cmMakefile::SetPolicyVersion(std::string const& version_min,
+                                  std::string const& version_max)
 {
-  return cmPolicies::ApplyPolicyVersion(this, version);
+  return cmPolicies::ApplyPolicyVersion(this, version_min, version_max);
 }
 
 bool cmMakefile::HasCMP0054AlreadyBeenReported(
@@ -4164,7 +4248,7 @@ static const char* const CXX_FEATURES[] = { nullptr FOR_EACH_CXX_FEATURE(
 #undef FEATURE_STRING
 
 static const char* const C_STANDARDS[] = { "90", "99", "11" };
-static const char* const CXX_STANDARDS[] = { "98", "11", "14", "17" };
+static const char* const CXX_STANDARDS[] = { "98", "11", "14", "17", "20" };
 
 bool cmMakefile::AddRequiredTargetFeature(cmTarget* target,
                                           const std::string& feature,
@@ -4238,8 +4322,9 @@ bool cmMakefile::CompileFeatureKnown(cmTarget const* target,
   } else {
     e << "Specified";
   }
-  e << " unknown feature \"" << feature << "\" for "
-                                           "target \""
+  e << " unknown feature \"" << feature
+    << "\" for "
+       "target \""
     << target->GetName() << "\".";
   if (error) {
     *error = e.str();
@@ -4414,8 +4499,9 @@ bool cmMakefile::HaveCxxStandardAvailable(cmTarget const* target,
   bool needCxx11 = false;
   bool needCxx14 = false;
   bool needCxx17 = false;
+  bool needCxx20 = false;
   this->CheckNeededCxxLanguage(feature, needCxx98, needCxx11, needCxx14,
-                               needCxx17);
+                               needCxx17, needCxx20);
 
   const char* existingCxxStandard = target->GetProperty("CXX_STANDARD");
   if (!existingCxxStandard) {
@@ -4435,7 +4521,8 @@ bool cmMakefile::HaveCxxStandardAvailable(cmTarget const* target,
 
   /* clang-format off */
   const char* const* needCxxLevel =
-    needCxx17 ? &CXX_STANDARDS[3]
+    needCxx20 ? &CXX_STANDARDS[4]
+    : needCxx17 ? &CXX_STANDARDS[3]
     : needCxx14 ? &CXX_STANDARDS[2]
     : needCxx11 ? &CXX_STANDARDS[1]
     : needCxx98 ? &CXX_STANDARDS[0]
@@ -4447,7 +4534,8 @@ bool cmMakefile::HaveCxxStandardAvailable(cmTarget const* target,
 
 void cmMakefile::CheckNeededCxxLanguage(const std::string& feature,
                                         bool& needCxx98, bool& needCxx11,
-                                        bool& needCxx14, bool& needCxx17) const
+                                        bool& needCxx14, bool& needCxx17,
+                                        bool& needCxx20) const
 {
   if (const char* propCxx98 =
         this->GetDefinition("CMAKE_CXX98_COMPILE_FEATURES")) {
@@ -4473,6 +4561,12 @@ void cmMakefile::CheckNeededCxxLanguage(const std::string& feature,
     cmSystemTools::ExpandListArgument(propCxx17, props);
     needCxx17 = std::find(props.begin(), props.end(), feature) != props.end();
   }
+  if (const char* propCxx20 =
+        this->GetDefinition("CMAKE_CXX20_COMPILE_FEATURES")) {
+    std::vector<std::string> props;
+    cmSystemTools::ExpandListArgument(propCxx20, props);
+    needCxx20 = std::find(props.begin(), props.end(), feature) != props.end();
+  }
 }
 
 bool cmMakefile::AddRequiredTargetCxxFeature(cmTarget* target,
@@ -4483,9 +4577,10 @@ bool cmMakefile::AddRequiredTargetCxxFeature(cmTarget* target,
   bool needCxx11 = false;
   bool needCxx14 = false;
   bool needCxx17 = false;
+  bool needCxx20 = false;
 
   this->CheckNeededCxxLanguage(feature, needCxx98, needCxx11, needCxx14,
-                               needCxx17);
+                               needCxx17, needCxx20);
 
   const char* existingCxxStandard = target->GetProperty("CXX_STANDARD");
   const char* const* existingCxxLevel = nullptr;
@@ -4530,7 +4625,8 @@ bool cmMakefile::AddRequiredTargetCxxFeature(cmTarget* target,
 
   /* clang-format off */
   const char* const* needCxxLevel =
-    needCxx17 ? &CXX_STANDARDS[3]
+    needCxx20 ? &CXX_STANDARDS[4]
+    : needCxx17 ? &CXX_STANDARDS[3]
     : needCxx14 ? &CXX_STANDARDS[2]
     : needCxx11 ? &CXX_STANDARDS[1]
     : needCxx98 ? &CXX_STANDARDS[0]
diff --git a/Source/cmMakefile.h b/Source/cmMakefile.h
index 5a30790dc..a7c8df559 100644
--- a/Source/cmMakefile.h
+++ b/Source/cmMakefile.h
@@ -27,7 +27,7 @@
 #include "cmake.h"
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
-#include "cmSourceGroup.h"
+#  include "cmSourceGroup.h"
 #endif
 
 class cmCommand;
@@ -102,7 +102,8 @@ 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, int jobs,
+                 const std::vector<std::string>* cmakeArgs,
                  std::string& output);
 
   bool GetIsSourceFileTryCompile() const;
@@ -168,6 +169,7 @@ public:
    */
   void AddDefineFlag(std::string const& definition);
   void RemoveDefineFlag(std::string const& definition);
+  void AddCompileDefinition(std::string const& definition);
   void AddCompileOption(std::string const& option);
 
   /** Create a new imported target with the name and type given.  */
@@ -280,12 +282,14 @@ public:
 
   //@{
   /**
-     * Set, Push, Pop policy values for CMake.
-     */
+   * Set, Push, Pop policy values for CMake.
+   */
   bool SetPolicy(cmPolicies::PolicyID id, cmPolicies::PolicyStatus status);
   bool SetPolicy(const char* id, cmPolicies::PolicyStatus status);
-  cmPolicies::PolicyStatus GetPolicyStatus(cmPolicies::PolicyID id) const;
-  bool SetPolicyVersion(const char* version);
+  cmPolicies::PolicyStatus GetPolicyStatus(cmPolicies::PolicyID id,
+                                           bool parent_scope = false) const;
+  bool SetPolicyVersion(std::string const& version_min,
+                        std::string const& version_max);
   void RecordPolicies(cmPolicies::PolicyMap& pm);
   //@}
 
@@ -562,12 +566,11 @@ 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 = nullptr,
-                                      long line = -1, bool removeEmpty = false,
-                                      bool replaceAt = false) const;
+  const std::string& ExpandVariablesInString(std::string& source) const;
+  const std::string& ExpandVariablesInString(
+    std::string& source, bool escapeQuotes, bool noEscapes,
+    bool atOnly = false, const char* filename = nullptr, long line = -1,
+    bool removeEmpty = false, bool replaceAt = false) const;
 
   /**
    * Remove any remaining variables in the string. Anything with ${var} or
@@ -721,6 +724,7 @@ public:
     ~FunctionPushPop();
 
     void Quiet() { this->ReportError = false; }
+
   private:
     cmMakefile* Makefile;
     bool ReportError;
@@ -734,6 +738,7 @@ public:
     ~MacroPushPop();
 
     void Quiet() { this->ReportError = false; }
+
   private:
     cmMakefile* Makefile;
     bool ReportError;
@@ -764,6 +769,7 @@ public:
       this->Makefile->PushScope();
     }
     ~ScopePushPop() { this->Makefile->PopScope(); }
+
   private:
     cmMakefile* Makefile;
   };
@@ -832,9 +838,11 @@ public:
   void RemoveExportBuildFileGeneratorCMP0024(cmExportBuildFileGenerator* gen);
   void AddExportBuildFileGenerator(cmExportBuildFileGenerator* gen);
 
-  // Maintain a stack of package names to determine the depth of find modules
-  // we are currently being called with
-  std::deque<std::string> FindPackageModuleStack;
+  // Maintain a stack of package roots to allow nested PACKAGE_ROOT_PATH
+  // searches
+  std::deque<std::vector<std::string>> FindPackageRootPathStack;
+
+  void MaybeWarnCMP0074(std::string const& pkg);
 
 protected:
   // add link libraries and directories to the target
@@ -861,6 +869,9 @@ protected:
   typedef std::unordered_map<std::string, SourceFileVec> SourceFileMap;
   SourceFileMap SourceFileSearchIndex;
 
+  // For "Known" paths we can store a direct filename to cmSourceFile map
+  std::unordered_map<std::string, cmSourceFile*> KnownFileSearchIndex;
+
   // Tests
   std::map<std::string, cmTest*> Tests;
 
@@ -878,9 +889,6 @@ protected:
   std::string DefineFlags;
 
   // Track the value of the computed DEFINITIONS property.
-  void AddDefineFlag(std::string const& flag, std::string&);
-  void RemoveDefineFlag(std::string const& flag, std::string::size_type,
-                        std::string&);
   std::string DefineFlagsOrig;
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
@@ -985,7 +993,7 @@ private:
                             bool& needC99, bool& needC11) const;
   void CheckNeededCxxLanguage(const std::string& feature, bool& needCxx98,
                               bool& needCxx11, bool& needCxx14,
-                              bool& needCxx17) const;
+                              bool& needCxx17, bool& needCxx20) const;
 
   bool HaveCStandardAvailable(cmTarget const* target,
                               const std::string& feature) const;
@@ -998,6 +1006,7 @@ private:
   bool WarnUnused;
   bool CheckSystemVars;
   bool CheckCMP0000;
+  std::set<std::string> WarnedCMP0074;
   bool IsSourceFileTryCompile;
   mutable bool SuppressWatches;
 };
diff --git a/Source/cmMakefileExecutableTargetGenerator.cxx b/Source/cmMakefileExecutableTargetGenerator.cxx
index 9bbc04337..1e59f44ce 100644
--- a/Source/cmMakefileExecutableTargetGenerator.cxx
+++ b/Source/cmMakefileExecutableTargetGenerator.cxx
@@ -477,8 +477,8 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
       this->LocalGenerator->GetCurrentBinaryDirectory(),
       targetFullPathImport));
     std::string implib;
-    if (this->GeneratorTarget->GetImplibGNUtoMS(targetFullPathImport,
-                                                implib)) {
+    if (this->GeneratorTarget->GetImplibGNUtoMS(
+          this->ConfigName, targetFullPathImport, implib)) {
       exeCleanFiles.push_back(this->LocalGenerator->MaybeConvertToRelativePath(
         this->LocalGenerator->GetCurrentBinaryDirectory(), implib));
     }
diff --git a/Source/cmMakefileLibraryTargetGenerator.cxx b/Source/cmMakefileLibraryTargetGenerator.cxx
index 9299ffe33..c53899285 100644
--- a/Source/cmMakefileLibraryTargetGenerator.cxx
+++ b/Source/cmMakefileLibraryTargetGenerator.cxx
@@ -5,6 +5,7 @@
 #include <algorithm>
 #include <memory> // IWYU pragma: keep
 #include <sstream>
+#include <stddef.h>
 #include <vector>
 
 #include "cmGeneratedFileStream.h"
@@ -641,8 +642,8 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules(
       this->LocalGenerator->GetCurrentBinaryDirectory(),
       targetFullPathImport));
     std::string implib;
-    if (this->GeneratorTarget->GetImplibGNUtoMS(targetFullPathImport,
-                                                implib)) {
+    if (this->GeneratorTarget->GetImplibGNUtoMS(
+          this->ConfigName, targetFullPathImport, implib)) {
       libCleanFiles.push_back(this->LocalGenerator->MaybeConvertToRelativePath(
         this->LocalGenerator->GetCurrentBinaryDirectory(), implib));
     }
@@ -732,10 +733,14 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules(
     // Archiving rules never use a response file.
     useResponseFileForObjects = false;
 
-    // Limit the length of individual object lists to less than the
-    // 32K command line length limit on Windows.  We could make this a
-    // platform file variable but this should work everywhere.
-    archiveCommandLimit = 30000;
+    // Limit the length of individual object lists to less than half of
+    // the command line length limit (leaving half for other flags).
+    // This may result in several calls to the archiver.
+    if (size_t limit = cmSystemTools::CalculateCommandLineLengthLimit()) {
+      archiveCommandLimit = limit / 2;
+    } else {
+      archiveCommandLimit = 8000;
+    }
   }
 
   // Expand the rule variables.
diff --git a/Source/cmMakefileTargetGenerator.cxx b/Source/cmMakefileTargetGenerator.cxx
index 73cf1f0fb..1f65f0896 100644
--- a/Source/cmMakefileTargetGenerator.cxx
+++ b/Source/cmMakefileTargetGenerator.cxx
@@ -643,6 +643,19 @@ void cmMakefileTargetGenerator::WriteObjectBuildFile(
         source.GetFullPath(), workingDirectory, compileCommand);
     }
 
+    // See if we need to use a compiler launcher like ccache or distcc
+    std::string compilerLauncher;
+    if (!compileCommands.empty() &&
+        (lang == "C" || lang == "CXX" || lang == "Fortran" ||
+         lang == "CUDA")) {
+      std::string const clauncher_prop = lang + "_COMPILER_LAUNCHER";
+      const char* clauncher =
+        this->GeneratorTarget->GetProperty(clauncher_prop);
+      if (clauncher && *clauncher) {
+        compilerLauncher = clauncher;
+      }
+    }
+
     // 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";
@@ -656,6 +669,13 @@ void cmMakefileTargetGenerator::WriteObjectBuildFile(
       if ((iwyu && *iwyu) || (tidy && *tidy) || (cpplint && *cpplint) ||
           (cppcheck && *cppcheck)) {
         std::string run_iwyu = "$(CMAKE_COMMAND) -E __run_co_compile";
+        if (!compilerLauncher.empty()) {
+          // In __run_co_compile case the launcher command is supplied
+          // via --launcher=<maybe-list> and consumed
+          run_iwyu += " --launcher=";
+          run_iwyu += this->LocalGenerator->EscapeForShell(compilerLauncher);
+          compilerLauncher.clear();
+        }
         if (iwyu && *iwyu) {
           run_iwyu += " --iwyu=";
           run_iwyu += this->LocalGenerator->EscapeForShell(iwyu);
@@ -682,21 +702,15 @@ void cmMakefileTargetGenerator::WriteObjectBuildFile(
       }
     }
 
-    // Maybe insert a compiler launcher like ccache or distcc
-    if (!compileCommands.empty() && (lang == "C" || lang == "CXX" ||
-                                     lang == "Fortran" || lang == "CUDA")) {
-      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::string& i : launcher_cmd) {
-          i = this->LocalGenerator->EscapeForShell(i);
-        }
-        std::string const& run_launcher = cmJoin(launcher_cmd, " ") + " ";
-        compileCommands.front().insert(0, run_launcher);
+    // If compiler launcher was specified and not consumed above, it
+    // goes to the beginning of the command line.
+    if (!compileCommands.empty() && !compilerLauncher.empty()) {
+      std::vector<std::string> args;
+      cmSystemTools::ExpandListArgument(compilerLauncher, args, true);
+      for (std::string& i : args) {
+        i = this->LocalGenerator->EscapeForShell(i);
       }
+      compileCommands.front().insert(0, cmJoin(args, " ") + " ");
     }
 
     std::string launcher;
@@ -1014,10 +1028,11 @@ void cmMakefileTargetGenerator::WriteTargetDependRules()
   // 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->ConvertToOutputFormat(
-                       cmSystemTools::CollapseFullPath(
-                         this->LocalGenerator->GetBinaryDirectory()),
-                       cmOutputConverter::SHELL))
+  depCmd << "cd "
+         << (this->LocalGenerator->ConvertToOutputFormat(
+              cmSystemTools::CollapseFullPath(
+                this->LocalGenerator->GetBinaryDirectory()),
+              cmOutputConverter::SHELL))
          << " && ";
 #endif
   // Generate a call this signature:
@@ -1389,7 +1404,7 @@ std::string cmMakefileTargetGenerator::GetLinkRule(
   const std::string& linkRuleVar)
 {
   std::string linkRule = this->Makefile->GetRequiredDefinition(linkRuleVar);
-  if (this->GeneratorTarget->HasImplibGNUtoMS()) {
+  if (this->GeneratorTarget->HasImplibGNUtoMS(this->ConfigName)) {
     std::string ruleVar = "CMAKE_";
     ruleVar += this->GeneratorTarget->GetLinkerLanguage(this->ConfigName);
     ruleVar += "_GNUtoMS_RULE";
diff --git a/Source/cmMessenger.cxx b/Source/cmMessenger.cxx
index 3ae5bc5c2..a81428aed 100644
--- a/Source/cmMessenger.cxx
+++ b/Source/cmMessenger.cxx
@@ -8,7 +8,7 @@
 #include "cmSystemTools.h"
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
-#include "cmsys/SystemInformation.hxx"
+#  include "cmsys/SystemInformation.hxx"
 #endif
 
 #include <sstream>
diff --git a/Source/cmNinjaNormalTargetGenerator.cxx b/Source/cmNinjaNormalTargetGenerator.cxx
index ddbc772fe..739418866 100644
--- a/Source/cmNinjaNormalTargetGenerator.cxx
+++ b/Source/cmNinjaNormalTargetGenerator.cxx
@@ -148,16 +148,18 @@ std::string cmNinjaNormalTargetGenerator::LanguageLinkerRule() const
 {
   return this->TargetLinkLanguage + "_" +
     cmState::GetTargetTypeName(this->GetGeneratorTarget()->GetType()) +
-    "_LINKER__" + cmGlobalNinjaGenerator::EncodeRuleName(
-                    this->GetGeneratorTarget()->GetName());
+    "_LINKER__" +
+    cmGlobalNinjaGenerator::EncodeRuleName(
+           this->GetGeneratorTarget()->GetName());
 }
 
 std::string cmNinjaNormalTargetGenerator::LanguageLinkerDeviceRule() const
 {
   return this->TargetLinkLanguage + "_" +
     cmState::GetTargetTypeName(this->GetGeneratorTarget()->GetType()) +
-    "_DEVICE_LINKER__" + cmGlobalNinjaGenerator::EncodeRuleName(
-                           this->GetGeneratorTarget()->GetName());
+    "_DEVICE_LINKER__" +
+    cmGlobalNinjaGenerator::EncodeRuleName(
+           this->GetGeneratorTarget()->GetName());
 }
 
 struct cmNinjaRemoveNoOpCommands
@@ -187,7 +189,7 @@ void cmNinjaNormalTargetGenerator::WriteDeviceLinkRule(bool useResponseFile)
     std::string responseFlag;
     if (!useResponseFile) {
       vars.Objects = "$in";
-      vars.LinkLibraries = "$LINK_LIBRARIES";
+      vars.LinkLibraries = "$LINK_PATH $LINK_LIBRARIES";
     } else {
       std::string cmakeVarLang = "CMAKE_";
       cmakeVarLang += this->TargetLinkLanguage;
@@ -413,8 +415,9 @@ void cmNinjaNormalTargetGenerator::WriteLinkRule(bool useResponseFile)
       this->GetGlobalGenerator()->AddRule(
         "CMAKE_SYMLINK_EXECUTABLE",
         this->GetLocalGenerator()->BuildCommandLine(commandLines),
-        "Creating executable symlink $out", "Rule for creating "
-                                            "executable symlink.",
+        "Creating executable symlink $out",
+        "Rule for creating "
+        "executable symlink.",
         /*depfile*/ "",
         /*deptype*/ "",
         /*rspfile*/ "",
@@ -430,8 +433,9 @@ void cmNinjaNormalTargetGenerator::WriteLinkRule(bool useResponseFile)
       this->GetGlobalGenerator()->AddRule(
         "CMAKE_SYMLINK_LIBRARY",
         this->GetLocalGenerator()->BuildCommandLine(commandLines),
-        "Creating library symlink $out", "Rule for creating "
-                                         "library symlink.",
+        "Creating library symlink $out",
+        "Rule for creating "
+        "library symlink.",
         /*depfile*/ "",
         /*deptype*/ "",
         /*rspfile*/ "",
@@ -482,7 +486,7 @@ std::vector<std::string> cmNinjaNormalTargetGenerator::ComputeLinkCmd()
     const char* linkCmd = mf->GetDefinition(linkCmdVar);
     if (linkCmd) {
       std::string linkCmdStr = linkCmd;
-      if (this->GetGeneratorTarget()->HasImplibGNUtoMS()) {
+      if (this->GetGeneratorTarget()->HasImplibGNUtoMS(this->ConfigName)) {
         std::string ruleVar = "CMAKE_";
         ruleVar += this->GeneratorTarget->GetLinkerLanguage(this->ConfigName);
         ruleVar += "_GNUtoMS_RULE";
@@ -715,9 +719,9 @@ void cmNinjaNormalTargetGenerator::WriteDeviceLinkStatement()
     static_cast<int>(cmSystemTools::CalculateCommandLineLengthLimit()) -
     globalGen.GetRuleCmdLength(this->LanguageLinkerDeviceRule());
 
-  const std::string rspfile =
+  const std::string rspfile = this->ConvertToNinjaPath(
     std::string(cmake::GetCMakeFilesDirectoryPostSlash()) +
-    genTarget.GetName() + ".rsp";
+    genTarget.GetName() + ".rsp");
 
   // Gather order-only dependencies.
   cmNinjaDeps orderOnlyDeps;
@@ -772,9 +776,9 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement()
   // Write comments.
   cmGlobalNinjaGenerator::WriteDivider(this->GetBuildFileStream());
   const cmStateEnums::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;
@@ -881,7 +885,7 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement()
       targetOutputImplib, cmOutputConverter::SHELL);
     vars["TARGET_IMPLIB"] = impLibPath;
     EnsureParentDirectoryExists(impLibPath);
-    if (genTarget.HasImportLibrary()) {
+    if (genTarget.HasImportLibrary(cfgName)) {
       byproducts.push_back(targetOutputImplib);
     }
   }
@@ -976,8 +980,10 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement()
     preLinkCmdLines.push_back("cd " + homeOutDir);
   }
 
-  vars["PRE_LINK"] = localGen.BuildCommandLine(preLinkCmdLines);
-  std::string postBuildCmdLine = localGen.BuildCommandLine(postBuildCmdLines);
+  vars["PRE_LINK"] = localGen.BuildCommandLine(preLinkCmdLines, "pre-link",
+                                               this->GeneratorTarget);
+  std::string postBuildCmdLine = localGen.BuildCommandLine(
+    postBuildCmdLines, "post-build", this->GeneratorTarget);
 
   cmNinjaVars symlinkVars;
   bool const symlinkNeeded =
@@ -999,9 +1005,9 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement()
       globalGen.GetRuleCmdLength(this->LanguageLinkerRule());
   }
 
-  const std::string rspfile =
+  const std::string rspfile = this->ConvertToNinjaPath(
     std::string(cmake::GetCMakeFilesDirectoryPostSlash()) + gt.GetName() +
-    ".rsp";
+    ".rsp");
 
   // Gather order-only dependencies.
   cmNinjaDeps orderOnlyDeps;
diff --git a/Source/cmNinjaTargetGenerator.cxx b/Source/cmNinjaTargetGenerator.cxx
index a6a3efbfb..9d4194826 100644
--- a/Source/cmNinjaTargetGenerator.cxx
+++ b/Source/cmNinjaTargetGenerator.cxx
@@ -445,72 +445,18 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang)
   cmMakefile* mf = this->GetMakefile();
 
   std::string flags = "$FLAGS";
-  std::string rspfile;
-  std::string rspcontent;
 
+  std::string responseFlag;
   bool const lang_supports_response = !(lang == "RC" || lang == "CUDA");
   if (lang_supports_response && this->ForceResponseFile()) {
     std::string const responseFlagVar =
       "CMAKE_" + lang + "_RESPONSE_FILE_FLAG";
-    std::string responseFlag =
-      this->Makefile->GetSafeDefinition(responseFlagVar);
+    responseFlag = this->Makefile->GetSafeDefinition(responseFlagVar);
     if (responseFlag.empty()) {
       responseFlag = "@";
     }
-    rspfile = "$RSP_FILE";
-    responseFlag += rspfile;
-    rspcontent = " $DEFINES $INCLUDES $FLAGS";
-    flags = std::move(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 (explicitPP) {
-    // The explicit preprocessing step will handle dependency scanning.
-  } else if (this->NeedDepTypeMSVC(lang)) {
-    deptype = "msvc";
-    depfile.clear();
-    flags += " /showIncludes";
-  } 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()) {
-      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 = "\"";
-      cldeps += cmSystemTools::GetCMClDepsCommand();
-      cldeps += "\" " + lang + " " + vars.Source + " $DEP_FILE $out \"";
-      cldeps += mf->GetSafeDefinition("CMAKE_CL_SHOWINCLUDES_PREFIX");
-      cldeps += "\" \"" + cl + "\" ";
-    }
-  } else {
-    deptype = "gcc";
-    const char* langdeptype = mf->GetDefinition("CMAKE_NINJA_DEPTYPE_" + lang);
-    if (langdeptype) {
-      deptype = langdeptype;
-    }
-    depfile = "$DEP_FILE";
-    const std::string flagsName = "CMAKE_DEPFILE_FLAGS_" + lang;
-    std::string depfileFlags = mf->GetSafeDefinition(flagsName);
-    if (!depfileFlags.empty()) {
-      cmSystemTools::ReplaceString(depfileFlags, "<DEPFILE>", "$DEP_FILE");
-      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();
-
   std::unique_ptr<cmRulePlaceholderExpander> rulePlaceholderExpander(
     this->GetLocalGenerator()->CreateRulePlaceholderExpander());
 
@@ -550,7 +496,7 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang)
     vars.Source = "$in";
 
     // Preprocessing and compilation use the same flags.
-    ppVars.Flags = vars.Flags;
+    std::string ppFlags = flags;
 
     // Move preprocessor definitions to the preprocessor rule.
     ppVars.Defines = vars.Defines;
@@ -560,6 +506,20 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang)
     // compilation rule still needs them for the INCLUDE directive.
     ppVars.Includes = vars.Includes;
 
+    // If using a response file, move defines, includes, and flags into it.
+    std::string ppRspFile;
+    std::string ppRspContent;
+    if (!responseFlag.empty()) {
+      ppRspFile = "$RSP_FILE";
+      ppRspContent = std::string(" ") + ppVars.Defines + " " +
+        ppVars.Includes + " " + ppFlags;
+      ppFlags = responseFlag + ppRspFile;
+      ppVars.Defines = "";
+      ppVars.Includes = "";
+    }
+
+    ppVars.Flags = ppFlags.c_str();
+
     // Rule for preprocessing source file.
     std::vector<std::string> ppCmds;
     cmSystemTools::ExpandListArgument(ppCmd, ppCmds);
@@ -574,10 +534,12 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang)
     std::string const cmake = this->GetLocalGenerator()->ConvertToOutputFormat(
       cmSystemTools::GetCMakeCommand(), cmLocalGenerator::SHELL);
     ppCmds.push_back(
-      cmake + " -E cmake_ninja_depends"
-              " --tdi=" +
-      tdi + " --pp=$out"
-            " --dep=$DEP_FILE" +
+      cmake +
+      " -E cmake_ninja_depends"
+      " --tdi=" +
+      tdi +
+      " --pp=$out"
+      " --dep=$DEP_FILE" +
       (needDyndep ? " --obj=$OBJ_FILE --ddi=$DYNDEP_INTERMEDIATE_FILE" : ""));
 
     std::string const ppCmdLine =
@@ -588,13 +550,11 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang)
     ppComment << "Rule for preprocessing " << lang << " files.";
     std::ostringstream ppDesc;
     ppDesc << "Building " << lang << " preprocessed $out";
-    this->GetGlobalGenerator()->AddRule(this->LanguagePreprocessRule(lang),
-                                        ppCmdLine, ppDesc.str(),
-                                        ppComment.str(), ppDepfile, ppDeptype,
-                                        /*rspfile*/ "",
-                                        /*rspcontent*/ "",
-                                        /*restat*/ "",
-                                        /*generator*/ false);
+    this->GetGlobalGenerator()->AddRule(
+      this->LanguagePreprocessRule(lang), ppCmdLine, ppDesc.str(),
+      ppComment.str(), ppDepfile, ppDeptype, ppRspFile, ppRspContent,
+      /*restat*/ "",
+      /*generator*/ false);
   }
 
   if (needDyndep) {
@@ -610,10 +570,12 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang)
     // Run CMake dependency scanner on preprocessed output.
     std::string const cmake = this->GetLocalGenerator()->ConvertToOutputFormat(
       cmSystemTools::GetCMakeCommand(), cmLocalGenerator::SHELL);
-    ddCmds.push_back(cmake + " -E cmake_ninja_dyndep"
-                             " --tdi=" +
-                     tdi + " --dd=$out"
-                           " " +
+    ddCmds.push_back(cmake +
+                     " -E cmake_ninja_dyndep"
+                     " --tdi=" +
+                     tdi +
+                     " --dd=$out"
+                     " " +
                      ddInput);
 
     std::string const ddCmdLine =
@@ -631,6 +593,64 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang)
       /*generator*/ false);
   }
 
+  // If using a response file, move defines, includes, and flags into it.
+  std::string rspfile;
+  std::string rspcontent;
+  if (!responseFlag.empty()) {
+    rspfile = "$RSP_FILE";
+    rspcontent =
+      std::string(" ") + vars.Defines + " " + vars.Includes + " " + flags;
+    flags = responseFlag + rspfile;
+    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 (explicitPP) {
+    // The explicit preprocessing step will handle dependency scanning.
+  } else if (this->NeedDepTypeMSVC(lang)) {
+    deptype = "msvc";
+    depfile.clear();
+    flags += " /showIncludes";
+  } 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()) {
+      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 = "\"";
+      cldeps += cmSystemTools::GetCMClDepsCommand();
+      cldeps += "\" " + lang + " " + vars.Source + " $DEP_FILE $out \"";
+      cldeps += mf->GetSafeDefinition("CMAKE_CL_SHOWINCLUDES_PREFIX");
+      cldeps += "\" \"" + cl + "\" ";
+    }
+  } else {
+    deptype = "gcc";
+    const char* langdeptype = mf->GetDefinition("CMAKE_NINJA_DEPTYPE_" + lang);
+    if (langdeptype) {
+      deptype = langdeptype;
+    }
+    depfile = "$DEP_FILE";
+    const std::string flagsName = "CMAKE_DEPFILE_FLAGS_" + lang;
+    std::string depfileFlags = mf->GetSafeDefinition(flagsName);
+    if (!depfileFlags.empty()) {
+      cmSystemTools::ReplaceString(depfileFlags, "<DEPFILE>", "$DEP_FILE");
+      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();
+
   // Rule for compiling object file.
   std::vector<std::string> compileCmds;
   if (lang == "CUDA") {
@@ -653,6 +673,17 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang)
     cmSystemTools::ExpandListArgument(compileCmd, compileCmds);
   }
 
+  // See if we need to use a compiler launcher like ccache or distcc
+  std::string compilerLauncher;
+  if (!compileCmds.empty() &&
+      (lang == "C" || lang == "CXX" || lang == "Fortran" || lang == "CUDA")) {
+    std::string const clauncher_prop = lang + "_COMPILER_LAUNCHER";
+    const char* clauncher = this->GeneratorTarget->GetProperty(clauncher_prop);
+    if (clauncher && *clauncher) {
+      compilerLauncher = clauncher;
+    }
+  }
+
   // Maybe insert an include-what-you-use runner.
   if (!compileCmds.empty() && (lang == "C" || lang == "CXX")) {
     std::string const iwyu_prop = lang + "_INCLUDE_WHAT_YOU_USE";
@@ -668,6 +699,13 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang)
       std::string run_iwyu = this->GetLocalGenerator()->ConvertToOutputFormat(
         cmSystemTools::GetCMakeCommand(), cmOutputConverter::SHELL);
       run_iwyu += " -E __run_co_compile";
+      if (!compilerLauncher.empty()) {
+        // In __run_co_compile case the launcher command is supplied
+        // via --launcher=<maybe-list> and consumed
+        run_iwyu += " --launcher=";
+        run_iwyu += this->LocalGenerator->EscapeForShell(compilerLauncher);
+        compilerLauncher.clear();
+      }
       if (iwyu && *iwyu) {
         run_iwyu += " --iwyu=";
         run_iwyu += this->GetLocalGenerator()->EscapeForShell(iwyu);
@@ -693,20 +731,15 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang)
     }
   }
 
-  // Maybe insert a compiler launcher like ccache or distcc
-  if (!compileCmds.empty() &&
-      (lang == "C" || lang == "CXX" || lang == "Fortran" || lang == "CUDA")) {
-    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::string& i : launcher_cmd) {
-        i = this->LocalGenerator->EscapeForShell(i);
-      }
-      std::string const& run_launcher = cmJoin(launcher_cmd, " ") + " ";
-      compileCmds.front().insert(0, run_launcher);
+  // If compiler launcher was specified and not consumed above, it
+  // goes to the beginning of the command line.
+  if (!compileCmds.empty() && !compilerLauncher.empty()) {
+    std::vector<std::string> args;
+    cmSystemTools::ExpandListArgument(compilerLauncher, args, true);
+    for (std::string& i : args) {
+      i = this->LocalGenerator->EscapeForShell(i);
     }
+    compileCmds.front().insert(0, cmJoin(args, " ") + " ");
   }
 
   if (!compileCmds.empty()) {
@@ -792,6 +825,19 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatements()
   orderOnlyDeps.erase(std::unique(orderOnlyDeps.begin(), orderOnlyDeps.end()),
                       orderOnlyDeps.end());
 
+  // The phony target must depend on at least one input or ninja will explain
+  // that "output ... of phony edge with no inputs doesn't exist" and consider
+  // the phony output "dirty".
+  if (orderOnlyDeps.empty()) {
+    // Any path that always exists will work here.  It would be nice to
+    // use just "." but that is not supported by Ninja < 1.7.
+    std::string tgtDir;
+    tgtDir += this->LocalGenerator->GetCurrentBinaryDirectory();
+    tgtDir += "/";
+    tgtDir += this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
+    orderOnlyDeps.push_back(this->ConvertToNinjaPath(tgtDir));
+  }
+
   {
     cmNinjaDeps orderOnlyTarget;
     orderOnlyTarget.push_back(this->OrderDependsTargetForTarget());
@@ -852,13 +898,36 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatement(
   std::string const objectFileDir =
     cmSystemTools::GetFilenamePath(objectFileName);
 
+  bool const lang_supports_response =
+    !(language == "RC" || language == "CUDA");
+  int const commandLineLengthLimit =
+    ((lang_supports_response && this->ForceResponseFile())) ? -1 : 0;
+
   cmNinjaVars vars;
   vars["FLAGS"] = this->ComputeFlagsForObject(source, language);
   vars["DEFINES"] = this->ComputeDefines(source, language);
   vars["INCLUDES"] = this->ComputeIncludes(source, language);
+
   if (!this->NeedDepTypeMSVC(language)) {
-    vars["DEP_FILE"] = this->GetLocalGenerator()->ConvertToOutputFormat(
-      objectFileName + ".d", cmOutputConverter::SHELL);
+    bool replaceExt(false);
+    if (!language.empty()) {
+      std::string repVar = "CMAKE_";
+      repVar += language;
+      repVar += "_DEPFILE_EXTENSION_REPLACE";
+      replaceExt = this->Makefile->IsOn(repVar);
+    }
+    if (!replaceExt) {
+      // use original code
+      vars["DEP_FILE"] = this->GetLocalGenerator()->ConvertToOutputFormat(
+        objectFileName + ".d", cmOutputConverter::SHELL);
+    } else {
+      // Replace the original source file extension with the
+      // depend file extension.
+      std::string dependFileName =
+        cmSystemTools::GetFilenameWithoutLastExtension(objectFileName) + ".d";
+      vars["DEP_FILE"] = this->GetLocalGenerator()->ConvertToOutputFormat(
+        objectFileDir + "/" + dependFileName, cmOutputConverter::SHELL);
+    }
   }
 
   this->ExportObjectCompileCommand(
@@ -983,9 +1052,12 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatement(
     this->addPoolNinjaVariable("JOB_POOL_COMPILE", this->GetGeneratorTarget(),
                                ppVars);
 
+    std::string const ppRspFile = ppFileName + ".rsp";
+
     this->GetGlobalGenerator()->WriteBuild(
       this->GetBuildFileStream(), ppComment, ppRule, ppOutputs, ppImplicitOuts,
-      ppExplicitDeps, ppImplicitDeps, ppOrderOnlyDeps, ppVars);
+      ppExplicitDeps, ppImplicitDeps, ppOrderOnlyDeps, ppVars, ppRspFile,
+      commandLineLengthLimit);
   }
   if (needDyndep) {
     std::string const dyndep = this->GetDyndepFilePath(language);
@@ -1005,10 +1077,6 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatement(
 
   this->SetMsvcTargetPdbVariable(vars);
 
-  bool const lang_supports_response =
-    !(language == "RC" || language == "CUDA");
-  int const commandLineLengthLimit =
-    ((lang_supports_response && this->ForceResponseFile())) ? -1 : 0;
   std::string const rspfile = objectFileName + ".rsp";
 
   this->GetGlobalGenerator()->WriteBuild(
@@ -1086,10 +1154,11 @@ void cmNinjaTargetGenerator::ExportObjectCompileCommand(
   std::string escapedSourceFileName = sourceFileName;
 
   if (!cmSystemTools::FileIsFullPath(sourceFileName)) {
-    escapedSourceFileName = cmSystemTools::CollapseFullPath(
-      escapedSourceFileName, this->GetGlobalGenerator()
-                               ->GetCMakeInstance()
-                               ->GetHomeOutputDirectory());
+    escapedSourceFileName =
+      cmSystemTools::CollapseFullPath(escapedSourceFileName,
+                                      this->GetGlobalGenerator()
+                                        ->GetCMakeInstance()
+                                        ->GetHomeOutputDirectory());
   }
 
   escapedSourceFileName = this->LocalGenerator->ConvertToOutputFormat(
diff --git a/Source/cmNinjaUtilityTargetGenerator.cxx b/Source/cmNinjaUtilityTargetGenerator.cxx
index 7adeb8e2b..cc6d4b988 100644
--- a/Source/cmNinjaUtilityTargetGenerator.cxx
+++ b/Source/cmNinjaUtilityTargetGenerator.cxx
@@ -96,8 +96,8 @@ void cmNinjaUtilityTargetGenerator::Generate()
       this->GetBuildFileStream(),
       "Utility command for " + this->GetTargetName(), outputs, deps);
   } else {
-    std::string command =
-      this->GetLocalGenerator()->BuildCommandLine(commands);
+    std::string command = this->GetLocalGenerator()->BuildCommandLine(
+      commands, "utility", this->GeneratorTarget);
     const char* echoStr =
       this->GetGeneratorTarget()->GetProperty("EchoString");
     std::string desc;
diff --git a/Source/cmOutputConverter.cxx b/Source/cmOutputConverter.cxx
index 25db92943..fd42c5341 100644
--- a/Source/cmOutputConverter.cxx
+++ b/Source/cmOutputConverter.cxx
@@ -6,7 +6,7 @@
 #include <assert.h>
 #include <ctype.h>
 #include <set>
-#include <sstream>
+#include <string.h>
 #include <vector>
 
 #include "cmAlgorithms.h"
@@ -341,12 +341,13 @@ redirection character (for example, ^>, ^<, or ^| ). If you need to
 use the caret character itself (^), use two in a row (^^).
 */
 
-int cmOutputConverter::Shell__CharIsWhitespace(char c)
+/* Some helpers to identify character classes */
+static int Shell__CharIsWhitespace(char c)
 {
   return ((c == ' ') || (c == '\t'));
 }
 
-int cmOutputConverter::Shell__CharNeedsQuotesOnUnix(char c)
+static int Shell__CharNeedsQuotesOnUnix(char c)
 {
   return ((c == '\'') || (c == '`') || (c == ';') || (c == '#') ||
           (c == '&') || (c == '$') || (c == '(') || (c == ')') || (c == '~') ||
@@ -354,12 +355,17 @@ int cmOutputConverter::Shell__CharNeedsQuotesOnUnix(char c)
           (c == '\\'));
 }
 
-int cmOutputConverter::Shell__CharNeedsQuotesOnWindows(char c)
+static int Shell__CharNeedsQuotesOnWindows(char c)
 {
   return ((c == '\'') || (c == '#') || (c == '&') || (c == '<') ||
           (c == '>') || (c == '|') || (c == '^'));
 }
 
+static int Shell__CharIsMakeVariableName(char c)
+{
+  return c && (c == '_' || isalpha((static_cast<int>(c))));
+}
+
 int cmOutputConverter::Shell__CharNeedsQuotes(char c, int flags)
 {
   /* On Windows the built-in command shell echo never needs quotes.  */
@@ -386,11 +392,6 @@ int cmOutputConverter::Shell__CharNeedsQuotes(char c, int flags)
   return 0;
 }
 
-int cmOutputConverter::Shell__CharIsMakeVariableName(char c)
-{
-  return c && (c == '_' || isalpha((static_cast<int>(c))));
-}
-
 const char* cmOutputConverter::Shell__SkipMakeVariables(const char* c)
 {
   while (*c == '$' && *(c + 1) == '(') {
@@ -481,7 +482,9 @@ int cmOutputConverter::Shell__ArgumentNeedsQuotes(const char* in, int flags)
 
 std::string cmOutputConverter::Shell__GetArgument(const char* in, int flags)
 {
-  std::ostringstream out;
+  /* Output will be at least as long as input string.  */
+  std::string out;
+  out.reserve(strlen(in));
 
   /* String iterator.  */
   const char* c;
@@ -495,11 +498,11 @@ std::string cmOutputConverter::Shell__GetArgument(const char* in, int flags)
     /* Add the opening quote for this argument.  */
     if (flags & Shell_Flag_WatcomQuote) {
       if (flags & Shell_Flag_IsUnix) {
-        out << '"';
+        out += '"';
       }
-      out << '\'';
+      out += '\'';
     } else {
-      out << '"';
+      out += '"';
     }
   }
 
@@ -511,7 +514,7 @@ std::string cmOutputConverter::Shell__GetArgument(const char* in, int flags)
       if (skip != c) {
         /* Copy to the end of the make variable references.  */
         while (c != skip) {
-          out << *c++;
+          out += *c++;
         }
 
         /* The make variable reference eliminates any escaping needed
@@ -531,7 +534,7 @@ std::string cmOutputConverter::Shell__GetArgument(const char* in, int flags)
          quoted argument.  */
       if (*c == '\\' || *c == '"' || *c == '`' || *c == '$') {
         /* This character needs a backslash to escape it.  */
-        out << '\\';
+        out += '\\';
       }
     } else if (flags & Shell_Flag_EchoWindows) {
       /* On Windows the built-in command shell echo never needs escaping.  */
@@ -545,11 +548,11 @@ std::string cmOutputConverter::Shell__GetArgument(const char* in, int flags)
            backslashes.  */
         while (windows_backslashes > 0) {
           --windows_backslashes;
-          out << '\\';
+          out += '\\';
         }
 
         /* Add the backslash to escape the double-quote.  */
-        out << '\\';
+        out += '\\';
       } else {
         /* We encountered a normal character.  This eliminates any
            escaping needed for preceding backslashes.  */
@@ -562,7 +565,7 @@ std::string cmOutputConverter::Shell__GetArgument(const char* in, int flags)
       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) {
         /* In a VS IDE a dollar is written "$".  If this is written in
            an un-quoted argument it starts a quoted segment, inserts
@@ -570,30 +573,30 @@ std::string cmOutputConverter::Shell__GetArgument(const char* in, int flags)
            argument it ends quoting, inserts the $ and restarts
            quoting.  Either way the $ is isolated from surrounding
            text to avoid looking like a variable reference.  */
-        out << "\"$\"";
+        out += "\"$\"";
       } else {
         /* Otherwise a dollar is written just $. */
-        out << '$';
+        out += '$';
       }
     } 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 {
         /* Otherwise a pound is written just #. */
-        out << '#';
+        out += '#';
       }
     } 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 {
         /* Otherwise a percent is written just %. */
-        out << '%';
+        out += '%';
       }
     } else if (*c == ';') {
       if (flags & Shell_Flag_VSIDE) {
@@ -602,14 +605,14 @@ std::string cmOutputConverter::Shell__GetArgument(const char* in, int flags)
            inserts the ; and ends the segment.  If it is written in a
            quoted argument it ends quoting, inserts the ; and restarts
            quoting.  Either way the ; is isolated.  */
-        out << "\";\"";
+        out += "\";\"";
       } else {
         /* Otherwise a semicolon is written just ;. */
-        out << ';';
+        out += ';';
       }
     } else {
       /* Store this character.  */
-      out << *c;
+      out += *c;
     }
   }
 
@@ -617,19 +620,19 @@ std::string cmOutputConverter::Shell__GetArgument(const char* in, int flags)
     /* Add enough backslashes to escape any trailing ones.  */
     while (windows_backslashes > 0) {
       --windows_backslashes;
-      out << '\\';
+      out += '\\';
     }
 
     /* Add the closing quote for this argument.  */
     if (flags & Shell_Flag_WatcomQuote) {
-      out << '\'';
+      out += '\'';
       if (flags & Shell_Flag_IsUnix) {
-        out << '"';
+        out += '"';
       }
     } else {
-      out << '"';
+      out += '"';
     }
   }
 
-  return out.str();
+  return out;
 }
diff --git a/Source/cmOutputConverter.h b/Source/cmOutputConverter.h
index ae15055ed..ed7143c43 100644
--- a/Source/cmOutputConverter.h
+++ b/Source/cmOutputConverter.h
@@ -117,11 +117,7 @@ public:
 private:
   cmState* GetState() const;
 
-  static int Shell__CharIsWhitespace(char c);
-  static int Shell__CharNeedsQuotesOnUnix(char c);
-  static int Shell__CharNeedsQuotesOnWindows(char c);
   static int Shell__CharNeedsQuotes(char c, int flags);
-  static int Shell__CharIsMakeVariableName(char c);
   static const char* Shell__SkipMakeVariables(const char* c);
   static int Shell__ArgumentNeedsQuotes(const char* in, int flags);
   static std::string Shell__GetArgument(const char* in, int flags);
diff --git a/Source/cmParseArgumentsCommand.cxx b/Source/cmParseArgumentsCommand.cxx
index 9a5b09721..2d61cc355 100644
--- a/Source/cmParseArgumentsCommand.cxx
+++ b/Source/cmParseArgumentsCommand.cxx
@@ -54,8 +54,8 @@ bool cmParseArgumentsCommand::InitialPass(std::vector<std::string> const& args,
     parseFromArgV = true;
     argIter++; // move past PARSE_ARGV
     if (!cmSystemTools::StringToULong(argIter->c_str(), &argvStart)) {
-      this->Makefile->IssueMessage(cmake::FATAL_ERROR, "PARSE_ARGV index '" +
-                                     *argIter +
+      this->Makefile->IssueMessage(cmake::FATAL_ERROR,
+                                   "PARSE_ARGV index '" + *argIter +
                                      "' is not an unsigned integer");
       cmSystemTools::SetFatalErrorOccured();
       return true;
diff --git a/Source/cmPolicies.cxx b/Source/cmPolicies.cxx
index e7d1b7218..ba50fb8ae 100644
--- a/Source/cmPolicies.cxx
+++ b/Source/cmPolicies.cxx
@@ -153,31 +153,26 @@ static bool GetPolicyDefault(cmMakefile* mf, std::string const& policy,
   return true;
 }
 
-bool cmPolicies::ApplyPolicyVersion(cmMakefile* mf, const char* version)
+bool cmPolicies::ApplyPolicyVersion(cmMakefile* mf,
+                                    std::string const& version_min,
+                                    std::string const& version_max)
 {
-  std::string ver = "2.4.0";
-
-  if (version && strlen(version) > 0) {
-    ver = version;
-  }
-
-  unsigned int majorVer = 2;
-  unsigned int minorVer = 0;
-  unsigned int patchVer = 0;
-  unsigned int tweakVer = 0;
-
-  // parse the string
-  if (sscanf(ver.c_str(), "%u.%u.%u.%u", &majorVer, &minorVer, &patchVer,
-             &tweakVer) < 2) {
+  // Parse components of the minimum version.
+  unsigned int minMajor = 2;
+  unsigned int minMinor = 0;
+  unsigned int minPatch = 0;
+  unsigned int minTweak = 0;
+  if (sscanf(version_min.c_str(), "%u.%u.%u.%u", &minMajor, &minMinor,
+             &minPatch, &minTweak) < 2) {
     std::ostringstream e;
-    e << "Invalid policy version value \"" << ver << "\".  "
+    e << "Invalid policy version value \"" << version_min << "\".  "
       << "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)) {
+  if (minMajor < 2 || (minMajor == 2 && minMinor < 4)) {
     mf->IssueMessage(
       cmake::FATAL_ERROR,
       "Compatibility with CMake < 2.4 is not supported by CMake >= 3.0.  "
@@ -188,19 +183,19 @@ bool cmPolicies::ApplyPolicyVersion(cmMakefile* mf, const char* version)
 
   // It is an error if the policy version is greater than the running
   // CMake.
-  if (majorVer > cmVersion::GetMajorVersion() ||
-      (majorVer == cmVersion::GetMajorVersion() &&
-       minorVer > cmVersion::GetMinorVersion()) ||
-      (majorVer == cmVersion::GetMajorVersion() &&
-       minorVer == cmVersion::GetMinorVersion() &&
-       patchVer > cmVersion::GetPatchVersion()) ||
-      (majorVer == cmVersion::GetMajorVersion() &&
-       minorVer == cmVersion::GetMinorVersion() &&
-       patchVer == cmVersion::GetPatchVersion() &&
-       tweakVer > cmVersion::GetTweakVersion())) {
+  if (minMajor > cmVersion::GetMajorVersion() ||
+      (minMajor == cmVersion::GetMajorVersion() &&
+       minMinor > cmVersion::GetMinorVersion()) ||
+      (minMajor == cmVersion::GetMajorVersion() &&
+       minMinor == cmVersion::GetMinorVersion() &&
+       minPatch > cmVersion::GetPatchVersion()) ||
+      (minMajor == cmVersion::GetMajorVersion() &&
+       minMinor == cmVersion::GetMinorVersion() &&
+       minPatch == cmVersion::GetPatchVersion() &&
+       minTweak > 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.  "
+      << version_min << "\" which is greater than this version of CMake.  "
       << "This is not allowed because the greater version may have new "
       << "policies not known to this CMake.  "
       << "You may need a newer CMake version to build this project.";
@@ -208,6 +203,52 @@ bool cmPolicies::ApplyPolicyVersion(cmMakefile* mf, const char* version)
     return false;
   }
 
+  unsigned int polMajor = minMajor;
+  unsigned int polMinor = minMinor;
+  unsigned int polPatch = minPatch;
+
+  if (!version_max.empty()) {
+    // Parse components of the maximum version.
+    unsigned int maxMajor = 0;
+    unsigned int maxMinor = 0;
+    unsigned int maxPatch = 0;
+    unsigned int maxTweak = 0;
+    if (sscanf(version_max.c_str(), "%u.%u.%u.%u", &maxMajor, &maxMinor,
+               &maxPatch, &maxTweak) < 2) {
+      std::ostringstream e;
+      e << "Invalid policy max version value \"" << version_max << "\".  "
+        << "A numeric major.minor[.patch[.tweak]] must be given.";
+      mf->IssueMessage(cmake::FATAL_ERROR, e.str());
+      return false;
+    }
+
+    // It is an error if the min version is greater than the max version.
+    if (minMajor > maxMajor || (minMajor == maxMajor && minMinor > maxMinor) ||
+        (minMajor == maxMajor && minMinor == maxMinor &&
+         minPatch > maxPatch) ||
+        (minMajor == maxMajor && minMinor == maxMinor &&
+         minPatch == maxPatch && minTweak > maxTweak)) {
+      std::ostringstream e;
+      e << "Policy VERSION range \"" << version_min << "..." << version_max
+        << "\""
+        << " specifies a larger minimum than maximum.";
+      mf->IssueMessage(cmake::FATAL_ERROR, e.str());
+      return false;
+    }
+
+    // Use the max version as the policy version.
+    polMajor = maxMajor;
+    polMinor = maxMinor;
+    polPatch = maxPatch;
+  }
+
+  return cmPolicies::ApplyPolicyVersion(mf, polMajor, polMinor, polPatch);
+}
+
+bool cmPolicies::ApplyPolicyVersion(cmMakefile* mf, unsigned int majorVer,
+                                    unsigned int minorVer,
+                                    unsigned int patchVer)
+{
   // now loop over all the policies and set them as appropriate
   std::vector<cmPolicies::PolicyID> ancientPolicies;
   for (PolicyID pid = cmPolicies::CMP0000; pid != cmPolicies::CMPCOUNT;
@@ -262,14 +303,17 @@ 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();
 }
 
@@ -293,19 +337,22 @@ std::string cmPolicies::GetPolicyDeprecatedWarning(cmPolicies::PolicyID id)
 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 "
+  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 "
+        << 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.";
diff --git a/Source/cmPolicies.h b/Source/cmPolicies.h
index c39f927c5..3fe0c844d 100644
--- a/Source/cmPolicies.h
+++ b/Source/cmPolicies.h
@@ -155,8 +155,9 @@ class cmMakefile;
          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.",                   \
+  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, \
@@ -214,7 +215,15 @@ class cmMakefile;
          3, 10, 0, cmPolicies::WARN)                                          \
   SELECT(POLICY, CMP0072,                                                     \
          "FindOpenGL prefers GLVND by default when available.", 3, 11, 0,     \
-         cmPolicies::WARN)
+         cmPolicies::WARN)                                                    \
+  SELECT(POLICY, CMP0073,                                                     \
+         "Do not produce legacy _LIB_DEPENDS cache entries.", 3, 12, 0,       \
+         cmPolicies::WARN)                                                    \
+  SELECT(POLICY, CMP0074, "find_package uses PackageName_ROOT variables.", 3, \
+         12, 0, cmPolicies::WARN)                                             \
+  SELECT(POLICY, CMP0075,                                                     \
+         "Include file check macros honor CMAKE_REQUIRED_LIBRARIES.", 3, 12,  \
+         0, cmPolicies::WARN)
 
 #define CM_SELECT_ID(F, A1, A2, A3, A4, A5, A6) F(A1)
 #define CM_FOR_EACH_POLICY_ID(POLICY)                                         \
@@ -238,14 +247,13 @@ class cmMakefile;
   F(CMP0063)                                                                  \
   F(CMP0065)                                                                  \
   F(CMP0068)                                                                  \
-  F(CMP0069)
+  F(CMP0069)                                                                  \
+  F(CMP0073)
 
 /** \class cmPolicies
  * \brief Handles changes in CMake behavior and policies
  *
- * See the cmake wiki section on
- * <a href="https://cmake.org/Wiki/CMake/Policies">policies</a>
- * for an overview of this class's purpose
+ * See the cmake-policies(7) manual for an overview of this class's purpose.
  */
 class cmPolicies
 {
@@ -284,7 +292,11 @@ public:
   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,
+                                 std::string const& version_min,
+                                 std::string const& version_max);
+  static bool ApplyPolicyVersion(cmMakefile* mf, unsigned int majorVer,
+                                 unsigned int minorVer, unsigned int patchVer);
 
   ///! return a warning string for a given policy
   static std::string GetPolicyWarning(cmPolicies::PolicyID id);
diff --git a/Source/cmProcessOutput.cxx b/Source/cmProcessOutput.cxx
index 83717061f..e4ca426cc 100644
--- a/Source/cmProcessOutput.cxx
+++ b/Source/cmProcessOutput.cxx
@@ -4,7 +4,7 @@
 #include "cmProcessOutput.h"
 
 #if defined(_WIN32)
-#include <windows.h>
+#  include <windows.h>
 unsigned int cmProcessOutput::defaultCodepage =
   KWSYS_ENCODING_DEFAULT_CODEPAGE;
 #endif
diff --git a/Source/cmProcessOutput.h b/Source/cmProcessOutput.h
index b5ec4a8be..400354c84 100644
--- a/Source/cmProcessOutput.h
+++ b/Source/cmProcessOutput.h
@@ -28,10 +28,10 @@ public:
   };
 
   /**
-  * Find encoding enum value for given encoding \a name.
-  * \param name a encoding name.
-  * \return encoding enum value or Auto if \a name was not found.
-  */
+   * Find encoding enum value for given encoding \a name.
+   * \param name a encoding name.
+   * \return encoding enum value or Auto if \a name was not found.
+   */
   static Encoding FindEncoding(std::string const& name);
 
   /// The code page that is used as internal encoding to which we will encode.
diff --git a/Source/cmProcessTools.h b/Source/cmProcessTools.h
index 23fa74e85..f1c2a228e 100644
--- a/Source/cmProcessTools.h
+++ b/Source/cmProcessTools.h
@@ -35,6 +35,7 @@ public:
     }
 
     virtual ~OutputParser() {}
+
   protected:
     /** Implement in a subclass to process a chunk of data.  It should
         return true only if it is interested in more data.  */
diff --git a/Source/cmProjectCommand.cxx b/Source/cmProjectCommand.cxx
index dfa185888..a25bd6b38 100644
--- a/Source/cmProjectCommand.cxx
+++ b/Source/cmProjectCommand.cxx
@@ -3,9 +3,11 @@
 #include "cmProjectCommand.h"
 
 #include "cmsys/RegularExpression.hxx"
+#include <functional>
 #include <sstream>
 #include <stdio.h>
 
+#include "cmAlgorithms.h"
 #include "cmMakefile.h"
 #include "cmPolicies.h"
 #include "cmStateTypes.h"
@@ -66,12 +68,19 @@ bool cmProjectCommand::InitialPass(std::vector<std::string> const& args,
   bool haveVersion = false;
   bool haveLanguages = false;
   bool haveDescription = false;
+  bool haveHomepage = false;
   std::string version;
   std::string description;
+  std::string homepage;
   std::vector<std::string> languages;
+  std::function<void()> missedValueReporter;
+  auto resetReporter = [&missedValueReporter]() {
+    missedValueReporter = std::function<void()>();
+  };
   enum Doing
   {
     DoingDescription,
+    DoingHomepage,
     DoingLanguages,
     DoingVersion
   };
@@ -85,7 +94,18 @@ bool cmProjectCommand::InitialPass(std::vector<std::string> const& args,
         return true;
       }
       haveLanguages = true;
+      if (missedValueReporter) {
+        missedValueReporter();
+      }
       doing = DoingLanguages;
+      if (!languages.empty()) {
+        std::string msg =
+          "the following parameters must be specified after LANGUAGES "
+          "keyword: ";
+        msg += cmJoin(languages, ", ");
+        msg += '.';
+        this->Makefile->IssueMessage(cmake::WARNING, msg);
+      }
     } else if (args[i] == "VERSION") {
       if (haveVersion) {
         this->Makefile->IssueMessage(cmake::FATAL_ERROR,
@@ -94,7 +114,17 @@ bool cmProjectCommand::InitialPass(std::vector<std::string> const& args,
         return true;
       }
       haveVersion = true;
+      if (missedValueReporter) {
+        missedValueReporter();
+      }
       doing = DoingVersion;
+      missedValueReporter = [this, &resetReporter]() {
+        this->Makefile->IssueMessage(
+          cmake::WARNING,
+          "VERSION keyword not followed by a value or was followed by a "
+          "value that expanded to nothing.");
+        resetReporter();
+      };
     } else if (args[i] == "DESCRIPTION") {
       if (haveDescription) {
         this->Makefile->IssueMessage(
@@ -103,23 +133,61 @@ bool cmProjectCommand::InitialPass(std::vector<std::string> const& args,
         return true;
       }
       haveDescription = true;
+      if (missedValueReporter) {
+        missedValueReporter();
+      }
       doing = DoingDescription;
+      missedValueReporter = [this, &resetReporter]() {
+        this->Makefile->IssueMessage(
+          cmake::WARNING,
+          "DESCRIPTION keyword not followed by a value or was followed "
+          "by a value that expanded to nothing.");
+        resetReporter();
+      };
+    } else if (args[i] == "HOMEPAGE_URL") {
+      if (haveHomepage) {
+        this->Makefile->IssueMessage(
+          cmake::FATAL_ERROR, "HOMEPAGE_URL may be specified at most once.");
+        cmSystemTools::SetFatalErrorOccured();
+        return true;
+      }
+      haveHomepage = true;
+      doing = DoingHomepage;
+      missedValueReporter = [this, &resetReporter]() {
+        this->Makefile->IssueMessage(
+          cmake::WARNING,
+          "HOMEPAGE_URL keyword not followed by a value or was followed "
+          "by a value that expanded to nothing.");
+        resetReporter();
+      };
     } else if (doing == DoingVersion) {
       doing = DoingLanguages;
       version = args[i];
+      resetReporter();
     } else if (doing == DoingDescription) {
       doing = DoingLanguages;
       description = args[i];
+      resetReporter();
+    } else if (doing == DoingHomepage) {
+      doing = DoingLanguages;
+      homepage = args[i];
+      resetReporter();
     } else // doing == DoingLanguages
     {
       languages.push_back(args[i]);
     }
   }
 
-  if (haveVersion && !haveLanguages && !languages.empty()) {
+  if (missedValueReporter) {
+    missedValueReporter();
+  }
+
+  if ((haveVersion || haveDescription || haveHomepage) && !haveLanguages &&
+      !languages.empty()) {
     this->Makefile->IssueMessage(
       cmake::FATAL_ERROR,
-      "project with VERSION must use LANGUAGES before language names.");
+      "project with VERSION, DESCRIPTION or HOMEPAGE_URL must "
+      "use LANGUAGES before language names.");
     cmSystemTools::SetFatalErrorOccured();
     return true;
   }
@@ -181,6 +249,12 @@ bool cmProjectCommand::InitialPass(std::vector<std::string> const& args,
     vv = projectName + "_VERSION_TWEAK";
     this->Makefile->AddDefinition("PROJECT_VERSION_TWEAK", vb[3]);
     this->Makefile->AddDefinition(vv, vb[3]);
+    // Also, try set top level variables
+    TopLevelCMakeVarCondSet("CMAKE_PROJECT_VERSION", vs.c_str());
+    TopLevelCMakeVarCondSet("CMAKE_PROJECT_VERSION_MAJOR", vb[0]);
+    TopLevelCMakeVarCondSet("CMAKE_PROJECT_VERSION_MINOR", vb[1]);
+    TopLevelCMakeVarCondSet("CMAKE_PROJECT_VERSION_PATCH", vb[2]);
+    TopLevelCMakeVarCondSet("CMAKE_PROJECT_VERSION_TWEAK", vb[3]);
   } else if (cmp0048 != cmPolicies::OLD) {
     // Set project VERSION variables to empty
     std::vector<std::string> vv;
@@ -194,6 +268,13 @@ bool cmProjectCommand::InitialPass(std::vector<std::string> const& args,
     vv.push_back(projectName + "_VERSION_MINOR");
     vv.push_back(projectName + "_VERSION_PATCH");
     vv.push_back(projectName + "_VERSION_TWEAK");
+    if (this->Makefile->IsRootMakefile()) {
+      vv.push_back("CMAKE_PROJECT_VERSION");
+      vv.push_back("CMAKE_PROJECT_VERSION_MAJOR");
+      vv.push_back("CMAKE_PROJECT_VERSION_MINOR");
+      vv.push_back("CMAKE_PROJECT_VERSION_PATCH");
+      vv.push_back("CMAKE_PROJECT_VERSION_TWEAK");
+    }
     std::string vw;
     for (std::string const& i : vv) {
       const char* v = this->Makefile->GetDefinition(i);
@@ -216,18 +297,16 @@ bool cmProjectCommand::InitialPass(std::vector<std::string> const& args,
 
   if (haveDescription) {
     this->Makefile->AddDefinition("PROJECT_DESCRIPTION", description.c_str());
-    // Set the CMAKE_PROJECT_DESCRIPTION variable to be the highest-level
-    // project name in the tree. If there are two project commands
-    // in the same CMakeLists.txt file, and it is the top level
-    // CMakeLists.txt file, then go with the last one.
-    if (!this->Makefile->GetDefinition("CMAKE_PROJECT_DESCRIPTION") ||
-        (this->Makefile->IsRootMakefile())) {
-      this->Makefile->AddDefinition("CMAKE_PROJECT_DESCRIPTION",
-                                    description.c_str());
-      this->Makefile->AddCacheDefinition(
-        "CMAKE_PROJECT_DESCRIPTION", description.c_str(),
-        "Value Computed by CMake", cmStateEnums::STATIC);
-    }
+    this->Makefile->AddDefinition(projectName + "_DESCRIPTION",
+                                  description.c_str());
+    TopLevelCMakeVarCondSet("CMAKE_PROJECT_DESCRIPTION", description.c_str());
+  }
+
+  if (haveHomepage) {
+    this->Makefile->AddDefinition("PROJECT_HOMEPAGE_URL", homepage.c_str());
+    this->Makefile->AddDefinition(projectName + "_HOMEPAGE_URL",
+                                  homepage.c_str());
+    TopLevelCMakeVarCondSet("CMAKE_PROJECT_HOMEPAGE_URL", homepage.c_str());
   }
 
   if (languages.empty()) {
@@ -250,3 +329,18 @@ bool cmProjectCommand::InitialPass(std::vector<std::string> const& args,
   }
   return true;
 }
+
+void cmProjectCommand::TopLevelCMakeVarCondSet(const char* const name,
+                                               const char* const value)
+{
+  // Set the CMAKE_PROJECT_XXX variable to be the highest-level
+  // project name in the tree. If there are two project commands
+  // in the same CMakeLists.txt file, and it is the top level
+  // CMakeLists.txt file, then go with the last one.
+  if (!this->Makefile->GetDefinition(name) ||
+      (this->Makefile->IsRootMakefile())) {
+    this->Makefile->AddDefinition(name, value);
+    this->Makefile->AddCacheDefinition(name, value, "Value Computed by CMake",
+                                       cmStateEnums::STATIC);
+  }
+}
diff --git a/Source/cmProjectCommand.h b/Source/cmProjectCommand.h
index 80fa235e2..365d4487a 100644
--- a/Source/cmProjectCommand.h
+++ b/Source/cmProjectCommand.h
@@ -34,6 +34,9 @@ public:
    */
   bool InitialPass(std::vector<std::string> const& args,
                    cmExecutionStatus& status) override;
+
+private:
+  void TopLevelCMakeVarCondSet(const char* name, const char* value);
 };
 
 #endif
diff --git a/Source/cmQtAutoGen.cxx b/Source/cmQtAutoGen.cxx
index 6e9ca443f..000529d36 100644
--- a/Source/cmQtAutoGen.cxx
+++ b/Source/cmQtAutoGen.cxx
@@ -55,8 +55,9 @@ void MergeOptions(std::vector<std::string>& baseOpts,
           }
         }
         // Test if this is a value option and change the existing value
-        if (!optName.empty() && (std::find(valueOpts.begin(), valueOpts.end(),
-                                           optName) != valueOpts.end())) {
+        if (!optName.empty() &&
+            (std::find(valueOpts.begin(), valueOpts.end(), optName) !=
+             valueOpts.end())) {
           const Iter existItNext(existIt + 1);
           const CIter fitNext(fit + 1);
           if ((existItNext != baseOpts.end()) && (fitNext != fitEnd)) {
diff --git a/Source/cmQtAutoGen.h b/Source/cmQtAutoGen.h
index 67f61b197..a3e16ac1a 100644
--- a/Source/cmQtAutoGen.h
+++ b/Source/cmQtAutoGen.h
@@ -34,7 +34,7 @@ public:
   /// @brief Returns the generator name in upper case
   static std::string GeneratorNameUpper(GeneratorT genType);
 
-  /// @brief Returns a the string escaped and enclosed in quotes
+  /// @brief Returns the string escaped and enclosed in quotes
   static std::string Quoted(std::string const& text);
 
   static std::string QuotedCommand(std::vector<std::string> const& command);
diff --git a/Source/cmQtAutoGenInitializer.cxx b/Source/cmQtAutoGenInitializer.cxx
index 566a2a98e..34196d9d8 100644
--- a/Source/cmQtAutoGenInitializer.cxx
+++ b/Source/cmQtAutoGenInitializer.cxx
@@ -1,7 +1,7 @@
 /* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
    file Copyright.txt or https://cmake.org/licensing for details.  */
-#include "cmQtAutoGen.h"
 #include "cmQtAutoGenInitializer.h"
+#include "cmQtAutoGen.h"
 
 #include "cmAlgorithms.h"
 #include "cmCustomCommand.h"
@@ -588,8 +588,13 @@ void cmQtAutoGenInitializer::InitCustomTargets()
           if (!qrc.Unique) {
             base += qrc.PathChecksum;
           }
+
+          qrc.LockFile = base;
+          qrc.LockFile += ".lock";
+
           qrc.InfoFile = base;
           qrc.InfoFile += "Info.cmake";
+
           qrc.SettingsFile = base;
           qrc.SettingsFile += "Settings.txt";
         }
@@ -623,14 +628,26 @@ void cmQtAutoGenInitializer::InitCustomTargets()
 
       std::vector<std::string> ccOutput;
       ccOutput.push_back(qrc.RccFile);
+
       cmCustomCommandLines commandLines;
-      {
+      if (this->MultiConfig) {
+        // Build for all configurations
+        for (std::string const& config : this->ConfigsList) {
+          cmCustomCommandLine currentLine;
+          currentLine.push_back(cmSystemTools::GetCMakeCommand());
+          currentLine.push_back("-E");
+          currentLine.push_back("cmake_autorcc");
+          currentLine.push_back(qrc.InfoFile);
+          currentLine.push_back(config);
+          commandLines.push_back(std::move(currentLine));
+        }
+      } else {
         cmCustomCommandLine currentLine;
         currentLine.push_back(cmSystemTools::GetCMakeCommand());
         currentLine.push_back("-E");
         currentLine.push_back("cmake_autorcc");
         currentLine.push_back(qrc.InfoFile);
-        currentLine.push_back("$<CONFIGURATION>");
+        currentLine.push_back("$<CONFIG>");
         commandLines.push_back(std::move(currentLine));
       }
       std::string ccComment = "Automatic RCC for ";
@@ -896,17 +913,18 @@ void cmQtAutoGenInitializer::SetupCustomTargets()
                                   std::vector<std::string> const& list) {
         CWrite(key, cmJoin(list, ";"));
       };
-      auto CWriteNestedLists = [&CWrite](
-        const char* key, std::vector<std::vector<std::string>> const& lists) {
-        std::vector<std::string> seplist;
-        for (const std::vector<std::string>& list : lists) {
-          std::string blist = "{";
-          blist += cmJoin(list, ";");
-          blist += "}";
-          seplist.push_back(std::move(blist));
-        }
-        CWrite(key, cmJoin(seplist, cmQtAutoGen::ListSep));
-      };
+      auto CWriteNestedLists =
+        [&CWrite](const char* key,
+                  std::vector<std::vector<std::string>> const& lists) {
+          std::vector<std::string> seplist;
+          for (const std::vector<std::string>& list : lists) {
+            std::string blist = "{";
+            blist += cmJoin(list, ";");
+            blist += "}";
+            seplist.push_back(std::move(blist));
+          }
+          CWrite(key, cmJoin(seplist, cmQtAutoGen::ListSep));
+        };
       auto CWriteSet = [&CWrite](const char* key,
                                  std::set<std::string> const& list) {
         CWrite(key, cmJoin(list, ";"));
@@ -1006,13 +1024,14 @@ void cmQtAutoGenInitializer::SetupCustomTargets()
           ofs << "set(" << key << " "
               << cmOutputConverter::EscapeForCMake(value) << ")\n";
         };
-        auto CWriteMap = [&ofs](
-          const char* key, std::map<std::string, std::string> const& map) {
-          for (auto const& item : map) {
-            ofs << "set(" << key << "_" << item.first << " "
-                << cmOutputConverter::EscapeForCMake(item.second) << ")\n";
-          }
-        };
+        auto CWriteMap =
+          [&ofs](const char* key,
+                 std::map<std::string, std::string> const& map) {
+            for (auto const& item : map) {
+              ofs << "set(" << key << "_" << item.first << " "
+                  << cmOutputConverter::EscapeForCMake(item.second) << ")\n";
+            }
+          };
 
         // Write
         ofs << "# Configurations\n";
@@ -1043,6 +1062,7 @@ void cmQtAutoGenInitializer::SetupCustomTargets()
         CWrite("ARCC_RCC_LIST_OPTIONS", cmJoin(this->RccListOptions, ";"));
 
         ofs << "# Rcc job\n";
+        CWrite("ARCC_LOCK_FILE", qrc.LockFile);
         CWrite("ARCC_SOURCE", qrc.QrcFile);
         CWrite("ARCC_OUTPUT_CHECKSUM", qrc.PathChecksum);
         CWrite("ARCC_OUTPUT_NAME",
diff --git a/Source/cmQtAutoGenInitializer.h b/Source/cmQtAutoGenInitializer.h
index 2a47e46a4..5fbf0cbdc 100644
--- a/Source/cmQtAutoGenInitializer.h
+++ b/Source/cmQtAutoGenInitializer.h
@@ -32,6 +32,7 @@ public:
     }
 
   public:
+    std::string LockFile;
     std::string QrcFile;
     std::string QrcName;
     std::string PathChecksum;
diff --git a/Source/cmQtAutoGenerator.cxx b/Source/cmQtAutoGenerator.cxx
index 4aa1b1fa4..7aa792f8a 100644
--- a/Source/cmQtAutoGenerator.cxx
+++ b/Source/cmQtAutoGenerator.cxx
@@ -1,7 +1,7 @@
 /* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
    file Copyright.txt or https://cmake.org/licensing for details.  */
-#include "cmQtAutoGen.h"
 #include "cmQtAutoGenerator.h"
+#include "cmQtAutoGen.h"
 
 #include "cmsys/FStream.hxx"
 
@@ -367,10 +367,11 @@ bool cmQtAutoGenerator::FileSystem::FileRemove(std::string const& filename)
   return cmSystemTools::RemoveFile(filename);
 }
 
-bool cmQtAutoGenerator::FileSystem::Touch(std::string const& filename)
+bool cmQtAutoGenerator::FileSystem::Touch(std::string const& filename,
+                                          bool create)
 {
   std::lock_guard<std::mutex> lock(Mutex_);
-  return cmSystemTools::Touch(filename, false);
+  return cmSystemTools::Touch(filename, create);
 }
 
 bool cmQtAutoGenerator::FileSystem::MakeDirectory(std::string const& dirname)
@@ -681,7 +682,7 @@ bool cmQtAutoGenerator::Run(std::string const& infoFile,
     auto makefile = cm::make_unique<cmMakefile>(&gg, snapshot);
     // The OLD/WARN behavior for policy CMP0053 caused a speed regression.
     // https://gitlab.kitware.com/cmake/cmake/issues/17570
-    makefile->SetPolicyVersion("3.9");
+    makefile->SetPolicyVersion("3.9", std::string());
     gg.SetCurrentMakefile(makefile.get());
     success = this->Init(makefile.get());
   }
diff --git a/Source/cmQtAutoGenerator.h b/Source/cmQtAutoGenerator.h
index 299e4c2a0..4e3841306 100644
--- a/Source/cmQtAutoGenerator.h
+++ b/Source/cmQtAutoGenerator.h
@@ -124,7 +124,7 @@ public:
     bool FileDiffers(std::string const& filename, std::string const& content);
 
     bool FileRemove(std::string const& filename);
-    bool Touch(std::string const& filename);
+    bool Touch(std::string const& filename, bool create = false);
 
     // -- Directory access
     bool MakeDirectory(std::string const& dirname);
diff --git a/Source/cmQtAutoGeneratorMocUic.cxx b/Source/cmQtAutoGeneratorMocUic.cxx
index e2fd15827..f196b97b9 100644
--- a/Source/cmQtAutoGeneratorMocUic.cxx
+++ b/Source/cmQtAutoGeneratorMocUic.cxx
@@ -1,7 +1,7 @@
 /* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
    file Copyright.txt or https://cmake.org/licensing for details.  */
-#include "cmQtAutoGen.h"
 #include "cmQtAutoGeneratorMocUic.h"
+#include "cmQtAutoGen.h"
 
 #include <algorithm>
 #include <array>
@@ -18,7 +18,7 @@
 #include "cmake.h"
 
 #if defined(__APPLE__)
-#include <unistd.h>
+#  include <unistd.h>
 #endif
 
 // -- Class methods
@@ -434,7 +434,7 @@ bool cmQtAutoGeneratorMocUic::JobParseT::ParseMocSource(WorkerT& wrk,
     JobHandleT jobHandle(new JobMocT(std::move(jobPre.SourceFile), FileName,
                                      std::move(jobPre.IncludeString)));
     if (jobPre.self) {
-      // Read depdendencies from this source
+      // Read dependencies from this source
       static_cast<JobMocT&>(*jobHandle).FindDependencies(wrk, meta.Content);
     }
     if (!wrk.Gen().ParallelJobPushMoc(jobHandle)) {
@@ -452,7 +452,7 @@ bool cmQtAutoGeneratorMocUic::JobParseT::ParseMocHeader(WorkerT& wrk,
   if (!macroName.empty()) {
     JobHandleT jobHandle(
       new JobMocT(std::string(FileName), std::string(), std::string()));
-    // Read depdendencies from this source
+    // Read dependencies from this source
     static_cast<JobMocT&>(*jobHandle).FindDependencies(wrk, meta.Content);
     success = wrk.Gen().ParallelJobPushMoc(jobHandle);
   }
@@ -1330,8 +1330,9 @@ bool cmQtAutoGeneratorMocUic::Init(cmMakefile* makefile)
       std::string error;
       // Insert default filter for Q_PLUGIN_METADATA
       if (Base().QtVersionMajor != 4) {
-        pushFilter("Q_PLUGIN_METADATA", "[\n][ \t]*Q_PLUGIN_METADATA[ \t]*\\("
-                                        "[^\\)]*FILE[ \t]*\"([^\"]+)\"",
+        pushFilter("Q_PLUGIN_METADATA",
+                   "[\n][ \t]*Q_PLUGIN_METADATA[ \t]*\\("
+                   "[^\\)]*FILE[ \t]*\"([^\"]+)\"",
                    error);
       }
       // Insert user defined dependency filters
@@ -1381,7 +1382,7 @@ bool cmQtAutoGeneratorMocUic::Init(cmMakefile* makefile)
       // Compare list sizes
       if (sources.size() != options.size()) {
         std::ostringstream ost;
-        ost << "files/options lists sizes missmatch (" << sources.size() << "/"
+        ost << "files/options lists sizes mismatch (" << sources.size() << "/"
             << options.size() << ")";
         Log().ErrorFile(GeneratorT::UIC, InfoFile(), ost.str());
         return false;
@@ -1884,7 +1885,7 @@ bool cmQtAutoGeneratorMocUic::ParallelJobPushMoc(JobHandleT& jobHandle)
               error += Quoted(mocJob.IncluderFile);
               error += " and\n  ";
               error += Quoted(otherJob.IncluderFile);
-              error += "\ncontain the the same moc include string ";
+              error += "\ncontain the same moc include string ";
               error += Quoted(mocJob.IncludeString);
               error += "\nbut the moc file would be generated from different "
                        "source files\n  ";
@@ -1933,7 +1934,7 @@ bool cmQtAutoGeneratorMocUic::ParallelJobPushUic(JobHandleT& jobHandle)
           error += Quoted(uicJob.IncluderFile);
           error += " and\n  ";
           error += Quoted(otherJob.IncluderFile);
-          error += "\ncontain the the same uic include string ";
+          error += "\ncontain the same uic include string ";
           error += Quoted(uicJob.IncludeString);
           error += "\nbut the uic file would be generated from different "
                    "source files\n  ";
diff --git a/Source/cmQtAutoGeneratorRcc.cxx b/Source/cmQtAutoGeneratorRcc.cxx
index 84ec5e2e4..3064895d7 100644
--- a/Source/cmQtAutoGeneratorRcc.cxx
+++ b/Source/cmQtAutoGeneratorRcc.cxx
@@ -1,10 +1,11 @@
 /* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
    file Copyright.txt or https://cmake.org/licensing for details.  */
-#include "cmQtAutoGen.h"
 #include "cmQtAutoGeneratorRcc.h"
+#include "cmQtAutoGen.h"
 
 #include "cmAlgorithms.h"
 #include "cmCryptoHash.h"
+#include "cmFileLockResult.h"
 #include "cmMakefile.h"
 #include "cmSystemTools.h"
 #include "cmUVHandlePtr.h"
@@ -89,6 +90,7 @@ bool cmQtAutoGeneratorRcc::Init(cmMakefile* makefile)
   RccListOptions_ = InfoGetList("ARCC_RCC_LIST_OPTIONS");
 
   // - Job
+  LockFile_ = InfoGet("ARCC_LOCK_FILE");
   QrcFile_ = InfoGet("ARCC_SOURCE");
   QrcFileName_ = cmSystemTools::GetFilenameName(QrcFile_);
   QrcFileDir_ = cmSystemTools::GetFilenamePath(QrcFile_);
@@ -101,6 +103,10 @@ bool cmQtAutoGeneratorRcc::Init(cmMakefile* makefile)
   SettingsFile_ = InfoGetConfig("ARCC_SETTINGS_FILE");
 
   // - Validity checks
+  if (LockFile_.empty()) {
+    Log().ErrorFile(GeneratorT::RCC, InfoFile(), "Lock file name missing");
+    return false;
+  }
   if (SettingsFile_.empty()) {
     Log().ErrorFile(GeneratorT::RCC, InfoFile(), "Settings file name missing");
     return false;
@@ -170,8 +176,11 @@ void cmQtAutoGeneratorRcc::PollStage()
   switch (Stage_) {
     // -- Initialize
     case StageT::SETTINGS_READ:
-      SettingsFileRead();
-      SetStage(StageT::TEST_QRC_RCC_FILES);
+      if (SettingsFileRead()) {
+        SetStage(StageT::TEST_QRC_RCC_FILES);
+      } else {
+        SetStage(StageT::FINISH);
+      }
       break;
 
     // -- Change detection
@@ -252,7 +261,7 @@ std::string cmQtAutoGeneratorRcc::MultiConfigOutput() const
   return res;
 }
 
-void cmQtAutoGeneratorRcc::SettingsFileRead()
+bool cmQtAutoGeneratorRcc::SettingsFileRead()
 {
   // Compose current settings strings
   {
@@ -278,21 +287,51 @@ void cmQtAutoGeneratorRcc::SettingsFileRead()
     }
   }
 
+  // Make sure the settings file exists
+  if (!FileSys().FileExists(SettingsFile_, true)) {
+    // Touch the settings file to make sure it exists
+    FileSys().Touch(SettingsFile_, true);
+  }
+
+  // Lock the lock file
+  {
+    // Make sure the lock file exists
+    if (!FileSys().FileExists(LockFile_, true)) {
+      if (!FileSys().Touch(LockFile_, true)) {
+        Log().ErrorFile(GeneratorT::RCC, LockFile_,
+                        "Lock file creation failed");
+        Error_ = true;
+        return false;
+      }
+    }
+    // Lock the lock file
+    cmFileLockResult lockResult =
+      LockFileLock_.Lock(LockFile_, static_cast<unsigned long>(-1));
+    if (!lockResult.IsOk()) {
+      Log().ErrorFile(GeneratorT::RCC, LockFile_,
+                      "File lock failed: " + lockResult.GetOutputMessage());
+      Error_ = true;
+      return false;
+    }
+  }
+
   // Read old settings
   {
     std::string content;
     if (FileSys().FileRead(content, SettingsFile_)) {
       SettingsChanged_ = (SettingsString_ != SettingsFind(content, "rcc"));
-      // In case any setting changed remove the old settings file.
+      // In case any setting changed clear the old settings file.
       // This triggers a full rebuild on the next run if the current
       // build is aborted before writing the current settings in the end.
       if (SettingsChanged_) {
-        FileSys().FileRemove(SettingsFile_);
+        FileSys().FileWrite(GeneratorT::RCC, SettingsFile_, "");
       }
     } else {
       SettingsChanged_ = true;
     }
   }
+
+  return true;
 }
 
 void cmQtAutoGeneratorRcc::SettingsFileWrite()
@@ -315,6 +354,9 @@ void cmQtAutoGeneratorRcc::SettingsFileWrite()
       Error_ = true;
     }
   }
+
+  // Unlock the lock file
+  LockFileLock_.Release();
 }
 
 bool cmQtAutoGeneratorRcc::TestQrcRccFiles()
diff --git a/Source/cmQtAutoGeneratorRcc.h b/Source/cmQtAutoGeneratorRcc.h
index 55e099811..74cec3661 100644
--- a/Source/cmQtAutoGeneratorRcc.h
+++ b/Source/cmQtAutoGeneratorRcc.h
@@ -5,6 +5,7 @@
 
 #include "cmConfigure.h" // IWYU pragma: keep
 
+#include "cmFileLock.h"
 #include "cmQtAutoGenerator.h"
 #include "cm_uv.h"
 
@@ -48,7 +49,7 @@ private:
   void PollStage();
   void SetStage(StageT stage);
   // -- Settings file
-  void SettingsFileRead();
+  bool SettingsFileRead();
   void SettingsFileWrite();
   // -- Tests
   bool TestQrcRccFiles();
@@ -77,6 +78,8 @@ private:
   std::string RccExecutable_;
   std::vector<std::string> RccListOptions_;
   // -- Job
+  std::string LockFile_;
+  cmFileLock LockFileLock_;
   std::string QrcFile_;
   std::string QrcFileName_;
   std::string QrcFileDir_;
diff --git a/Source/cmRST.cxx b/Source/cmRST.cxx
index 112be4d37..12817ae4b 100644
--- a/Source/cmRST.cxx
+++ b/Source/cmRST.cxx
@@ -34,11 +34,13 @@ cmRST::cmRST(std::ostream& os, std::string const& docroot)
   , NoteDirective("^.. note::[ \t]*(.*)$")
   , ModuleRST("^#\\[(=*)\\[\\.rst:$")
   , CMakeRole("(:cmake)?:("
-              "command|generator|variable|module|policy|"
+              "command|generator|variable|envvar|module|policy|"
               "prop_cache|prop_dir|prop_gbl|prop_inst|prop_sf|"
               "prop_test|prop_tgt|"
               "manual"
               "):`(<*([^`<]|[^` \t]<)*)([ \t]+<[^`]*>)?`")
+  , InlineLink("`(<*([^`<]|[^` \t]<)*)([ \t]+<[^`]*>)?`_")
+  , InlineLiteral("``([^`]*)``")
   , Substitution("(^|[^A-Za-z0-9_])"
                  "((\\|[^| \t\r\n]([^|\r\n]*[^| \t\r\n])?\\|)(__|_|))"
                  "([^A-Za-z0-9_]|$)")
@@ -152,8 +154,9 @@ 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) == std::string::npos ? MarkupEmpty
@@ -245,18 +248,62 @@ void cmRST::OutputLine(std::string const& line_in, bool inlineMarkup)
   if (inlineMarkup) {
     std::string line = this->ReplaceSubstitutions(line_in);
     std::string::size_type pos = 0;
-    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("()") == std::string::npos) {
-        text += "()";
+    for (;;) {
+      std::string::size_type* first = nullptr;
+      std::string::size_type role_start = std::string::npos;
+      std::string::size_type link_start = std::string::npos;
+      std::string::size_type lit_start = std::string::npos;
+      if (this->CMakeRole.find(line.c_str() + pos)) {
+        role_start = this->CMakeRole.start();
+        first = &role_start;
+      }
+      if (this->InlineLiteral.find(line.c_str() + pos)) {
+        lit_start = this->InlineLiteral.start();
+        if (!first || lit_start < *first) {
+          first = &lit_start;
+        }
+      }
+      if (this->InlineLink.find(line.c_str() + pos)) {
+        link_start = this->InlineLink.start();
+        if (!first || link_start < *first) {
+          first = &link_start;
+        }
+      }
+      if (first == &role_start) {
+        this->OS << line.substr(pos, role_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("()") == std::string::npos) {
+          text += "()";
+        }
+        this->OS << "``" << text << "``";
+        pos += this->CMakeRole.end();
+      } else if (first == &lit_start) {
+        this->OS << line.substr(pos, lit_start);
+        std::string text = this->InlineLiteral.match(1);
+        pos += this->InlineLiteral.end();
+        this->OS << "``" << text << "``";
+      } else if (first == &link_start) {
+        this->OS << line.substr(pos, link_start);
+        std::string text = this->InlineLink.match(1);
+        bool escaped = false;
+        for (char c : text) {
+          if (escaped) {
+            escaped = false;
+            this->OS << c;
+          } else if (c == '\\') {
+            escaped = true;
+          } else {
+            this->OS << c;
+          }
+        }
+        pos += this->InlineLink.end();
+      } else {
+        break;
       }
-      this->OS << "``" << text << "``";
-      pos += this->CMakeRole.end();
     }
     this->OS << line.substr(pos) << "\n";
   } else {
diff --git a/Source/cmRST.h b/Source/cmRST.h
index d1a8e2711..ee478677d 100644
--- a/Source/cmRST.h
+++ b/Source/cmRST.h
@@ -85,6 +85,8 @@ private:
   cmsys::RegularExpression NoteDirective;
   cmsys::RegularExpression ModuleRST;
   cmsys::RegularExpression CMakeRole;
+  cmsys::RegularExpression InlineLink;
+  cmsys::RegularExpression InlineLiteral;
   cmsys::RegularExpression Substitution;
   cmsys::RegularExpression TocTreeLink;
 
diff --git a/Source/cmRulePlaceholderExpander.h b/Source/cmRulePlaceholderExpander.h
index 7b19210d3..a7d8ceefb 100644
--- a/Source/cmRulePlaceholderExpander.h
+++ b/Source/cmRulePlaceholderExpander.h
@@ -24,7 +24,7 @@ public:
     this->TargetImpLib = targetImpLib;
   }
 
-  // Create a struct to hold the varibles passed into
+  // Create a struct to hold the variables passed into
   // ExpandRuleVariables
   struct RuleVariables
   {
diff --git a/Source/cmSearchPath.h b/Source/cmSearchPath.h
index fd0c7c52e..2a576ed59 100644
--- a/Source/cmSearchPath.h
+++ b/Source/cmSearchPath.h
@@ -39,10 +39,10 @@ public:
   void AddCMakePrefixPath(const std::string& variable);
   void AddEnvPrefixPath(const std::string& variable, bool stripBin = false);
   void AddSuffixes(const std::vector<std::string>& suffixes);
-
-protected:
   void AddPrefixPaths(const std::vector<std::string>& paths,
                       const char* base = nullptr);
+
+protected:
   void AddPathInternal(const std::string& path, const char* base = nullptr);
 
   cmFindCommon* FC;
diff --git a/Source/cmServerConnection.cxx b/Source/cmServerConnection.cxx
index 78c8f06bc..1fc8cf8ec 100644
--- a/Source/cmServerConnection.cxx
+++ b/Source/cmServerConnection.cxx
@@ -9,9 +9,9 @@
 
 #include <algorithm>
 #ifdef _WIN32
-#include "io.h"
+#  include "io.h"
 #else
-#include <unistd.h>
+#  include <unistd.h>
 #endif
 #include <cassert>
 
diff --git a/Source/cmServerProtocol.cxx b/Source/cmServerProtocol.cxx
index 7c10110b1..c26716013 100644
--- a/Source/cmServerProtocol.cxx
+++ b/Source/cmServerProtocol.cxx
@@ -300,7 +300,8 @@ static bool getOrTestValue(cmState* state, const std::string& key,
     value = cachedValue;
   }
   if (!cachedValue.empty() && cachedValue != value) {
-    setErrorMessage(errorMessage, std::string("\"") + key +
+    setErrorMessage(errorMessage,
+                    std::string("\"") + key +
                       "\" is set but incompatible with configured " +
                       keyDescription + " value.");
     return false;
@@ -320,7 +321,8 @@ bool cmServerProtocol1::DoActivate(const cmServerRequest& request,
   std::string platform = request.Data[kPLATFORM_KEY].asString();
 
   if (buildDirectory.empty()) {
-    setErrorMessage(errorMessage, std::string("\"") + kBUILD_DIRECTORY_KEY +
+    setErrorMessage(errorMessage,
+                    std::string("\"") + kBUILD_DIRECTORY_KEY +
                       "\" is missing.");
     return false;
   }
@@ -328,7 +330,8 @@ bool cmServerProtocol1::DoActivate(const cmServerRequest& request,
   cmake* cm = CMakeInstance();
   if (cmSystemTools::PathExists(buildDirectory)) {
     if (!cmSystemTools::FileIsDirectory(buildDirectory)) {
-      setErrorMessage(errorMessage, std::string("\"") + kBUILD_DIRECTORY_KEY +
+      setErrorMessage(errorMessage,
+                      std::string("\"") + kBUILD_DIRECTORY_KEY +
                         "\" exists but is not a directory.");
       return false;
     }
@@ -369,17 +372,20 @@ bool cmServerProtocol1::DoActivate(const cmServerRequest& request,
   }
 
   if (sourceDirectory.empty()) {
-    setErrorMessage(errorMessage, std::string("\"") + kSOURCE_DIRECTORY_KEY +
+    setErrorMessage(errorMessage,
+                    std::string("\"") + kSOURCE_DIRECTORY_KEY +
                       "\" is unset but required.");
     return false;
   }
   if (!cmSystemTools::FileIsDirectory(sourceDirectory)) {
-    setErrorMessage(errorMessage, std::string("\"") + kSOURCE_DIRECTORY_KEY +
+    setErrorMessage(errorMessage,
+                    std::string("\"") + kSOURCE_DIRECTORY_KEY +
                       "\" is not a directory.");
     return false;
   }
   if (generator.empty()) {
-    setErrorMessage(errorMessage, std::string("\"") + kGENERATOR_KEY +
+    setErrorMessage(errorMessage,
+                    std::string("\"") + kGENERATOR_KEY +
                       "\" is unset but required.");
     return false;
   }
@@ -391,7 +397,8 @@ bool cmServerProtocol1::DoActivate(const cmServerRequest& request,
                                return info.name == generator;
                              });
   if (baseIt == generators.end()) {
-    setErrorMessage(errorMessage, std::string("Generator \"") + generator +
+    setErrorMessage(errorMessage,
+                    std::string("Generator \"") + generator +
                       "\" not supported.");
     return false;
   }
@@ -629,8 +636,9 @@ struct hash<LanguageData>
     size_t result =
       hash<std::string>()(in.Language) ^ hash<std::string>()(in.Flags);
     for (auto const& i : in.IncludePathList) {
-      result = result ^ (hash<std::string>()(i.first) ^
-                         (i.second ? std::numeric_limits<size_t>::max() : 0));
+      result = result ^
+        (hash<std::string>()(i.first) ^
+         (i.second ? std::numeric_limits<size_t>::max() : 0));
     }
     for (auto const& i : in.Defines) {
       result = result ^ hash<std::string>()(i);
@@ -726,8 +734,9 @@ static Json::Value DumpSourceFilesList(
 
         for (const auto& include : includes) {
           fileData.IncludePathList.push_back(
-            std::make_pair(include, target->IsSystemIncludeDirectory(
-                                      include, config, fileData.Language)));
+            std::make_pair(include,
+                           target->IsSystemIncludeDirectory(
+                             include, config, fileData.Language)));
         }
       }
 
@@ -745,8 +754,9 @@ static Json::Value DumpSourceFilesList(
       const std::string defPropName =
         "COMPILE_DEFINITIONS_" + cmSystemTools::UpperCase(config);
       if (const char* config_defs = file->GetProperty(defPropName)) {
-        lg->AppendDefines(defines, genexInterpreter.Evaluate(
-                                     config_defs, COMPILE_DEFINITIONS));
+        lg->AppendDefines(
+          defines,
+          genexInterpreter.Evaluate(config_defs, COMPILE_DEFINITIONS));
       }
 
       defines.insert(ld.Defines.begin(), ld.Defines.end());
diff --git a/Source/cmSourceFileLocation.h b/Source/cmSourceFileLocation.h
index f325e547a..886a18458 100644
--- a/Source/cmSourceFileLocation.h
+++ b/Source/cmSourceFileLocation.h
@@ -81,6 +81,7 @@ public:
    * Get the cmMakefile instance for which the source file was created.
    */
   cmMakefile const* GetMakefile() const { return this->Makefile; }
+
 private:
   cmMakefile const* const Makefile;
   bool AmbiguousDirectory;
diff --git a/Source/cmSourceGroupCommand.cxx b/Source/cmSourceGroupCommand.cxx
index 8c9b63c6a..c3df313e1 100644
--- a/Source/cmSourceGroupCommand.cxx
+++ b/Source/cmSourceGroupCommand.cxx
@@ -101,9 +101,13 @@ bool addFilesToItsSourceGroups(const std::string& root,
       tokenizedPath = tokenizePath(sgFilesPath);
     }
 
-    if (tokenizedPath.size() > 1) {
+    if (!tokenizedPath.empty()) {
       tokenizedPath.pop_back();
 
+      if (tokenizedPath.empty()) {
+        tokenizedPath.push_back("");
+      }
+
       sg = makefile.GetOrCreateSourceGroup(tokenizedPath);
 
       if (!sg) {
diff --git a/Source/cmStandardLexer.h b/Source/cmStandardLexer.h
index b212c7e2d..13f7622a7 100644
--- a/Source/cmStandardLexer.h
+++ b/Source/cmStandardLexer.h
@@ -7,41 +7,41 @@
 
 /* Disable some warnings.  */
 #if defined(_MSC_VER)
-#pragma warning(disable : 4018)
-#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 : 4018)
+#  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
 
 #if defined(__GNUC__) && !defined(__INTEL_COMPILER)
-#if ((__GNUC__ * 100) + __GNUC_MINOR__) >= 402
-#pragma GCC diagnostic ignored "-Wconversion"
-#pragma GCC diagnostic ignored "-Wsign-compare"
-#endif
-#if ((__GNUC__ * 100) + __GNUC_MINOR__) >= 403
-#pragma GCC diagnostic ignored "-Wsign-conversion"
-#endif
+#  if ((__GNUC__ * 100) + __GNUC_MINOR__) >= 402
+#    pragma GCC diagnostic ignored "-Wconversion"
+#    pragma GCC diagnostic ignored "-Wsign-compare"
+#  endif
+#  if ((__GNUC__ * 100) + __GNUC_MINOR__) >= 403
+#    pragma GCC diagnostic ignored "-Wsign-conversion"
+#  endif
 #endif
 
 /* Make sure isatty is available. */
 #if defined(_WIN32) && !defined(__CYGWIN__)
-#include <io.h>
-#if defined(_MSC_VER)
-#define isatty _isatty
-#endif
+#  include <io.h>
+#  if defined(_MSC_VER)
+#    define isatty _isatty
+#  endif
 #else
-#include <unistd.h> // IWYU pragma: export
+#  include <unistd.h> // IWYU pragma: export
 #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 bb891b579..a57be4db6 100644
--- a/Source/cmState.cxx
+++ b/Source/cmState.cxx
@@ -13,6 +13,7 @@
 #include "cmCommand.h"
 #include "cmDefinitions.h"
 #include "cmDisallowedCommand.h"
+#include "cmGlobVerificationManager.h"
 #include "cmListFileCache.h"
 #include "cmStatePrivate.h"
 #include "cmStateSnapshot.h"
@@ -31,11 +32,13 @@ cmState::cmState()
   , MSYSShell(false)
 {
   this->CacheManager = new cmCacheManager;
+  this->GlobVerificationManager = new cmGlobVerificationManager;
 }
 
 cmState::~cmState()
 {
   delete this->CacheManager;
+  delete this->GlobVerificationManager;
   cmDeleteAll(this->BuiltinCommands);
   cmDeleteAll(this->ScriptedCommands);
 }
@@ -207,6 +210,39 @@ void cmState::AddCacheEntry(const std::string& key, const char* value,
   this->CacheManager->AddCacheEntry(key, value, helpString, type);
 }
 
+bool cmState::DoWriteGlobVerifyTarget() const
+{
+  return this->GlobVerificationManager->DoWriteVerifyTarget();
+}
+
+std::string const& cmState::GetGlobVerifyScript() const
+{
+  return this->GlobVerificationManager->GetVerifyScript();
+}
+
+std::string const& cmState::GetGlobVerifyStamp() const
+{
+  return this->GlobVerificationManager->GetVerifyStamp();
+}
+
+bool cmState::SaveVerificationScript(const std::string& path)
+{
+  return this->GlobVerificationManager->SaveVerificationScript(path);
+}
+
+void cmState::AddGlobCacheEntry(bool recurse, bool listDirectories,
+                                bool followSymlinks,
+                                const std::string& relative,
+                                const std::string& expression,
+                                const std::vector<std::string>& files,
+                                const std::string& variable,
+                                cmListFileBacktrace const& backtrace)
+{
+  this->GlobVerificationManager->AddCacheEntry(
+    recurse, listDirectories, followSymlinks, relative, expression, files,
+    variable, backtrace);
+}
+
 void cmState::RemoveCacheEntry(std::string const& key)
 {
   this->CacheManager->RemoveCacheEntry(key);
@@ -426,13 +462,17 @@ void cmState::AddScriptedCommand(std::string const& name, cmCommand* command)
 
 cmCommand* cmState::GetCommand(std::string const& name) const
 {
-  std::string sName = cmSystemTools::LowerCase(name);
+  return GetCommandByExactName(cmSystemTools::LowerCase(name));
+}
+
+cmCommand* cmState::GetCommandByExactName(std::string const& name) const
+{
   std::map<std::string, cmCommand*>::const_iterator pos;
-  pos = this->ScriptedCommands.find(sName);
+  pos = this->ScriptedCommands.find(name);
   if (pos != this->ScriptedCommands.end()) {
     return pos->second;
   }
-  pos = this->BuiltinCommands.find(sName);
+  pos = this->BuiltinCommands.find(name);
   if (pos != this->BuiltinCommands.end()) {
     return pos->second;
   }
diff --git a/Source/cmState.h b/Source/cmState.h
index 6cbf82d5c..38bdfec7d 100644
--- a/Source/cmState.h
+++ b/Source/cmState.h
@@ -12,6 +12,7 @@
 
 #include "cmDefinitions.h"
 #include "cmLinkedTree.h"
+#include "cmListFileCache.h"
 #include "cmPolicies.h"
 #include "cmProperty.h"
 #include "cmPropertyDefinitionMap.h"
@@ -21,6 +22,7 @@
 
 class cmCacheManager;
 class cmCommand;
+class cmGlobVerificationManager;
 class cmPropertyDefinition;
 class cmStateSnapshot;
 class cmMessenger;
@@ -123,7 +125,11 @@ public:
   bool GetIsGeneratorMultiConfig() const;
   void SetIsGeneratorMultiConfig(bool b);
 
+  // Returns a command from its name, case insensitive, or nullptr
   cmCommand* GetCommand(std::string const& name) const;
+  // Returns a command from its name, or nullptr
+  cmCommand* GetCommandByExactName(std::string const& name) const;
+
   void AddBuiltinCommand(std::string const& name, cmCommand* command);
   void AddDisallowedCommand(std::string const& name, cmCommand* command,
                             cmPolicies::PolicyID policy, const char* message);
@@ -165,12 +171,24 @@ private:
                      const char* helpString,
                      cmStateEnums::CacheEntryType type);
 
+  bool DoWriteGlobVerifyTarget() const;
+  std::string const& GetGlobVerifyScript() const;
+  std::string const& GetGlobVerifyStamp() const;
+  bool SaveVerificationScript(const std::string& path);
+  void AddGlobCacheEntry(bool recurse, bool listDirectories,
+                         bool followSymlinks, const std::string& relative,
+                         const std::string& expression,
+                         const std::vector<std::string>& files,
+                         const std::string& variable,
+                         cmListFileBacktrace const& bt);
+
   std::map<cmProperty::ScopeType, cmPropertyDefinitionMap> PropertyDefinitions;
   std::vector<std::string> EnabledLanguages;
   std::map<std::string, cmCommand*> BuiltinCommands;
   std::map<std::string, cmCommand*> ScriptedCommands;
   cmPropertyMap GlobalProperties;
   cmCacheManager* CacheManager;
+  cmGlobVerificationManager* GlobVerificationManager;
 
   cmLinkedTree<cmStateDetail::BuildsystemDirectoryStateType>
     BuildsystemDirectory;
diff --git a/Source/cmStateSnapshot.cxx b/Source/cmStateSnapshot.cxx
index 479ecd228..8f5f58c95 100644
--- a/Source/cmStateSnapshot.cxx
+++ b/Source/cmStateSnapshot.cxx
@@ -6,7 +6,7 @@
 #include <algorithm>
 #include <assert.h>
 #include <iterator>
-#include <stdio.h>
+#include <string>
 
 #include "cmAlgorithms.h"
 #include "cmDefinitions.h"
@@ -19,11 +19,11 @@
 #include "cmake.h"
 
 #if !defined(_WIN32)
-#include <sys/utsname.h>
+#  include <sys/utsname.h>
 #endif
 
 #if defined(__CYGWIN__)
-#include "cmSystemTools.h"
+#  include "cmSystemTools.h"
 #endif
 
 cmStateSnapshot::cmStateSnapshot(cmState* state)
@@ -160,8 +160,8 @@ void cmStateSnapshot::SetPolicy(cmPolicies::PolicyID id,
   }
 }
 
-cmPolicies::PolicyStatus cmStateSnapshot::GetPolicy(
-  cmPolicies::PolicyID id) const
+cmPolicies::PolicyStatus cmStateSnapshot::GetPolicy(cmPolicies::PolicyID id,
+                                                    bool parent_scope) const
 {
   cmPolicies::PolicyStatus status = cmPolicies::GetPolicyStatus(id);
 
@@ -180,6 +180,10 @@ cmPolicies::PolicyStatus cmStateSnapshot::GetPolicy(
     cmLinkedTree<cmStateDetail::PolicyStackEntry>::iterator root =
       dir->DirectoryEnd->PolicyRoot;
     for (; leaf != root; ++leaf) {
+      if (parent_scope) {
+        parent_scope = false;
+        continue;
+      }
       if (leaf->IsDefined(id)) {
         status = leaf->Get(id);
         return status;
@@ -328,15 +332,14 @@ void cmStateSnapshot::SetDefaultDefinitions()
   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_MAJOR_VERSION",
+                      std::to_string(cmVersion::GetMajorVersion()));
+  this->SetDefinition("CMAKE_MINOR_VERSION",
+                      std::to_string(cmVersion::GetMinorVersion()));
+  this->SetDefinition("CMAKE_PATCH_VERSION",
+                      std::to_string(cmVersion::GetPatchVersion()));
+  this->SetDefinition("CMAKE_TWEAK_VERSION",
+                      std::to_string(cmVersion::GetTweakVersion()));
   this->SetDefinition("CMAKE_VERSION", cmVersion::GetCMakeVersion());
 
   this->SetDefinition("CMAKE_FILES_DIRECTORY",
diff --git a/Source/cmStateSnapshot.h b/Source/cmStateSnapshot.h
index 94d6274b9..af5653b99 100644
--- a/Source/cmStateSnapshot.h
+++ b/Source/cmStateSnapshot.h
@@ -43,7 +43,8 @@ public:
   cmStateEnums::SnapshotType GetType() const;
 
   void SetPolicy(cmPolicies::PolicyID id, cmPolicies::PolicyStatus status);
-  cmPolicies::PolicyStatus GetPolicy(cmPolicies::PolicyID id) const;
+  cmPolicies::PolicyStatus GetPolicy(cmPolicies::PolicyID id,
+                                     bool parent_scope = false) const;
   bool HasDefinedPolicyCMP0011();
   void PushPolicy(cmPolicies::PolicyMap const& entry, bool weak);
   bool PopPolicy();
diff --git a/Source/cmStringCommand.cxx b/Source/cmStringCommand.cxx
index 55af0785d..ed88a1e72 100644
--- a/Source/cmStringCommand.cxx
+++ b/Source/cmStringCommand.cxx
@@ -13,6 +13,7 @@
 #include "cmCryptoHash.h"
 #include "cmGeneratorExpression.h"
 #include "cmMakefile.h"
+#include "cmStringReplaceHelper.h"
 #include "cmSystemTools.h"
 #include "cmTimestamp.h"
 #include "cmUuid.h"
@@ -68,6 +69,9 @@ bool cmStringCommand::InitialPass(std::vector<std::string> const& args,
   if (subCommand == "CONCAT") {
     return this->HandleConcatCommand(args);
   }
+  if (subCommand == "JOIN") {
+    return this->HandleJoinCommand(args);
+  }
   if (subCommand == "SUBSTRING") {
     return this->HandleSubstringCommand(args);
   }
@@ -341,46 +345,17 @@ bool cmStringCommand::RegexReplace(std::vector<std::string> const& args)
   std::string const& regex = args[2];
   std::string const& replace = args[3];
   std::string const& outvar = args[4];
+  cmStringReplaceHelper replaceHelper(regex, replace, this->Makefile);
 
-  // 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()) {
-    std::string::size_type r = replace.find('\\', l);
-    if (r == std::string::npos) {
-      r = replace.length();
-      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)) {
-        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') {
-        replacement.push_back("\n");
-      } else if (replace[r + 1] == '\\') {
-        replacement.push_back("\\");
-      } 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;
+  if (!replaceHelper.IsReplaceExpressionValid()) {
+    this->SetError(
+      "sub-command REGEX, mode REPLACE: " + replaceHelper.GetError() + ".");
+    return false;
   }
 
   this->Makefile->ClearMatches();
-  // Compile the regular expression.
-  cmsys::RegularExpression re;
-  if (!re.compile(regex.c_str())) {
+
+  if (!replaceHelper.IsRegularExpressionValid()) {
     std::string e =
       "sub-command REGEX, mode REPLACE failed to compile regex \"" + regex +
       "\".";
@@ -389,60 +364,16 @@ bool cmStringCommand::RegexReplace(std::vector<std::string> const& args)
   }
 
   // Concatenate all the last arguments together.
-  std::string input = cmJoin(cmMakeRange(args).advance(5), std::string());
-
-  // Scan through the input for all matches.
+  const std::string input =
+    cmJoin(cmMakeRange(args).advance(5), std::string());
   std::string output;
-  std::string::size_type base = 0;
-  while (re.find(input.c_str() + base)) {
-    this->Makefile->ClearMatches();
-    this->Makefile->StoreMatches(re);
-    std::string::size_type l2 = re.start();
-    std::string::size_type r = re.end();
-
-    // Concatenate the part of the input that was not matched.
-    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.";
-      this->SetError(e);
-      return false;
-    }
-
-    // Concatenate the replacement for the match.
-    for (RegexReplacement const& i : replacement) {
-      if (i.number < 0) {
-        // This is just a plain-text part of the replacement.
-        output += i.value;
-      } else {
-        // Replace with part of the match.
-        int n = 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 e =
-            "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;
+  if (!replaceHelper.Replace(input, output)) {
+    this->SetError(
+      "sub-command REGEX, mode REPLACE: " + replaceHelper.GetError() + ".");
+    return false;
   }
 
-  // Concatenate the text after the last match.
-  output += input.substr(base, input.length() - base);
-
   // Store the output in the provided variable.
   this->Makefile->AddDefinition(outvar, output.c_str());
   return true;
@@ -677,8 +608,26 @@ bool cmStringCommand::HandleConcatCommand(std::vector<std::string> const& args)
     return false;
   }
 
-  std::string const& variableName = args[1];
-  std::string value = cmJoin(cmMakeRange(args).advance(2), std::string());
+  return this->joinImpl(args, std::string(), 1);
+}
+
+bool cmStringCommand::HandleJoinCommand(std::vector<std::string> const& args)
+{
+  if (args.size() < 3) {
+    this->SetError("sub-command JOIN requires at least two arguments.");
+    return false;
+  }
+
+  return this->joinImpl(args, args[1], 2);
+}
+
+bool cmStringCommand::joinImpl(std::vector<std::string> const& args,
+                               std::string const& glue, const size_t varIdx)
+{
+  std::string const& variableName = args[varIdx];
+  // NOTE Items to concat/join placed right after the variable for
+  // both `CONCAT` and `JOIN` sub-commands.
+  std::string value = cmJoin(cmMakeRange(args).advance(varIdx + 1), glue);
 
   this->Makefile->AddDefinition(variableName, value.c_str());
   return true;
diff --git a/Source/cmStringCommand.h b/Source/cmStringCommand.h
index b287e37b7..cbff73e99 100644
--- a/Source/cmStringCommand.h
+++ b/Source/cmStringCommand.h
@@ -5,6 +5,7 @@
 
 #include "cmConfigure.h" // IWYU pragma: keep
 
+#include <cstddef>
 #include <string>
 #include <vector>
 
@@ -48,6 +49,7 @@ protected:
   bool HandleAppendCommand(std::vector<std::string> const& args);
   bool HandlePrependCommand(std::vector<std::string> const& args);
   bool HandleConcatCommand(std::vector<std::string> const& args);
+  bool HandleJoinCommand(std::vector<std::string> const& args);
   bool HandleStripCommand(std::vector<std::string> const& args);
   bool HandleRandomCommand(std::vector<std::string> const& args);
   bool HandleFindCommand(std::vector<std::string> const& args);
@@ -56,28 +58,8 @@ protected:
   bool HandleGenexStripCommand(std::vector<std::string> const& args);
   bool HandleUuidCommand(std::vector<std::string> const& args);
 
-  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() {}
-    int number;
-    std::string value;
-  };
+  bool joinImpl(std::vector<std::string> const& args, std::string const& glue,
+                size_t varIdx);
 };
 
 #endif
diff --git a/Source/cmStringReplaceHelper.cxx b/Source/cmStringReplaceHelper.cxx
new file mode 100644
index 000000000..69b7cedd6
--- /dev/null
+++ b/Source/cmStringReplaceHelper.cxx
@@ -0,0 +1,117 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+
+#include "cmStringReplaceHelper.h"
+
+#include "cmMakefile.h"
+#include <sstream>
+
+cmStringReplaceHelper::cmStringReplaceHelper(const std::string& regex,
+                                             const std::string& replace_expr,
+                                             cmMakefile* makefile)
+  : RegExString(regex)
+  , RegularExpression(regex)
+  , ReplaceExpression(replace_expr)
+  , Makefile(makefile)
+{
+  this->ParseReplaceExpression();
+}
+
+bool cmStringReplaceHelper::Replace(const std::string& input,
+                                    std::string& output)
+{
+  output.clear();
+
+  // Scan through the input for all matches.
+  std::string::size_type base = 0;
+  while (this->RegularExpression.find(input.c_str() + base)) {
+    if (this->Makefile != nullptr) {
+      this->Makefile->ClearMatches();
+      this->Makefile->StoreMatches(this->RegularExpression);
+    }
+    auto l2 = this->RegularExpression.start();
+    auto r = this->RegularExpression.end();
+
+    // Concatenate the part of the input that was not matched.
+    output += input.substr(base, l2);
+
+    // Make sure the match had some text.
+    if (r - l2 == 0) {
+      std::ostringstream error;
+      error << "regex \"" << this->RegExString << "\" matched an empty string";
+      this->ErrorString = error.str();
+      return false;
+    }
+
+    // Concatenate the replacement for the match.
+    for (const auto& replacement : this->Replacements) {
+      if (replacement.Number < 0) {
+        // This is just a plain-text part of the replacement.
+        output += replacement.Value;
+      } else {
+        // Replace with part of the match.
+        auto n = replacement.Number;
+        auto start = this->RegularExpression.start(n);
+        auto end = this->RegularExpression.end(n);
+        auto 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::ostringstream error;
+          error << "replace expression \"" << this->ReplaceExpression
+                << "\" contains an out-of-range escape for regex \""
+                << this->RegExString << "\"";
+          this->ErrorString = error.str();
+          return false;
+        }
+      }
+    }
+
+    // Move past the match.
+    base += r;
+  }
+
+  // Concatenate the text after the last match.
+  output += input.substr(base, input.length() - base);
+
+  return true;
+}
+
+void cmStringReplaceHelper::ParseReplaceExpression()
+{
+  std::string::size_type l = 0;
+  while (l < this->ReplaceExpression.length()) {
+    auto r = this->ReplaceExpression.find('\\', l);
+    if (r == std::string::npos) {
+      r = this->ReplaceExpression.length();
+      this->Replacements.push_back(this->ReplaceExpression.substr(l, r - l));
+    } else {
+      if (r - l > 0) {
+        this->Replacements.push_back(this->ReplaceExpression.substr(l, r - l));
+      }
+      if (r == (this->ReplaceExpression.length() - 1)) {
+        this->ValidReplaceExpression = false;
+        this->ErrorString = "replace-expression ends in a backslash";
+        return;
+      }
+      if ((this->ReplaceExpression[r + 1] >= '0') &&
+          (this->ReplaceExpression[r + 1] <= '9')) {
+        this->Replacements.push_back(this->ReplaceExpression[r + 1] - '0');
+      } else if (this->ReplaceExpression[r + 1] == 'n') {
+        this->Replacements.push_back("\n");
+      } else if (this->ReplaceExpression[r + 1] == '\\') {
+        this->Replacements.push_back("\\");
+      } else {
+        this->ValidReplaceExpression = false;
+        std::ostringstream error;
+        error << "Unknown escape \"" << this->ReplaceExpression.substr(r, 2)
+              << "\" in replace-expression";
+        this->ErrorString = error.str();
+        return;
+      }
+      r += 2;
+    }
+    l = r;
+  }
+}
diff --git a/Source/cmStringReplaceHelper.h b/Source/cmStringReplaceHelper.h
new file mode 100644
index 000000000..938325a31
--- /dev/null
+++ b/Source/cmStringReplaceHelper.h
@@ -0,0 +1,69 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmStringReplaceHelper_h
+#define cmStringReplaceHelper_h
+
+#include "cmsys/RegularExpression.hxx"
+
+#include <string>
+#include <vector>
+
+class cmMakefile;
+
+class cmStringReplaceHelper
+{
+public:
+  cmStringReplaceHelper(const std::string& regex,
+                        const std::string& replace_expr,
+                        cmMakefile* makefile = nullptr);
+
+  bool IsRegularExpressionValid() const
+  {
+    return this->RegularExpression.is_valid();
+  }
+  bool IsReplaceExpressionValid() const
+  {
+    return this->ValidReplaceExpression;
+  }
+
+  bool Replace(const std::string& input, std::string& output);
+
+  const std::string& GetError() { return this->ErrorString; }
+
+private:
+  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() {}
+
+    int Number;
+    std::string Value;
+  };
+
+  void ParseReplaceExpression();
+
+  std::string ErrorString;
+  std::string RegExString;
+  cmsys::RegularExpression RegularExpression;
+  bool ValidReplaceExpression = true;
+  std::string ReplaceExpression;
+  std::vector<RegexReplacement> Replacements;
+  cmMakefile* Makefile = nullptr;
+};
+
+#endif
diff --git a/Source/cmSystemTools.cxx b/Source/cmSystemTools.cxx
index 9575c05cc..72fd2bbf9 100644
--- a/Source/cmSystemTools.cxx
+++ b/Source/cmSystemTools.cxx
@@ -8,24 +8,27 @@
 #include "cm_sys_stat.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
+#  ifndef __LA_SSIZE_T
+#    define __LA_SSIZE_T la_ssize_t
+#  endif
 #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
 
 #include "cmsys/Directory.hxx"
@@ -48,30 +51,30 @@
 #include <utility>
 
 #if defined(_WIN32)
-#include <windows.h>
+#  include <windows.h>
 // include wincrypt.h after windows.h
-#include <wincrypt.h>
+#  include <wincrypt.h>
 
-#include <fcntl.h> /* _O_TEXT */
+#  include <fcntl.h> /* _O_TEXT */
 
-#include "cm_uv.h"
+#  include "cm_uv.h"
 #else
-#include <sys/time.h>
-#include <unistd.h>
-#include <utime.h>
+#  include <sys/time.h>
+#  include <unistd.h>
+#  include <utime.h>
 #endif
 
 #if defined(_WIN32) &&                                                        \
   (defined(_MSC_VER) || defined(__WATCOMC__) || defined(__MINGW32__))
-#include <io.h>
+#  include <io.h>
 #endif
 
 #if defined(__APPLE__)
-#include <mach-o/dyld.h>
+#  include <mach-o/dyld.h>
 #endif
 
 #ifdef __QNX__
-#include <malloc.h> /* for malloc/free on QNX */
+#  include <malloc.h> /* for malloc/free on QNX */
 #endif
 
 static bool cm_isspace(char c)
@@ -93,32 +96,32 @@ public:
 
 #if !defined(HAVE_ENVIRON_NOT_REQUIRE_PROTOTYPE)
 // For GetEnvironmentVariables
-#if defined(_WIN32)
+#  if defined(_WIN32)
 extern __declspec(dllimport) char** environ;
-#else
+#  else
 extern char** environ;
-#endif
+#  endif
 #endif
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
 static std::string cm_archive_entry_pathname(struct archive_entry* entry)
 {
-#if cmsys_STL_HAS_WSTRING
+#  if cmsys_STL_HAS_WSTRING
   return cmsys::Encoding::ToNarrow(archive_entry_pathname_w(entry));
-#else
+#  else
   return archive_entry_pathname(entry);
-#endif
+#  endif
 }
 
 static int cm_archive_read_open_file(struct archive* a, const char* file,
                                      int block_size)
 {
-#if cmsys_STL_HAS_WSTRING
+#  if cmsys_STL_HAS_WSTRING
   std::wstring wfile = cmsys::Encoding::ToWide(file);
   return archive_read_open_filename_w(a, wfile.c_str(), block_size);
-#else
+#  else
   return archive_read_open_filename(a, file, block_size);
-#endif
+#  endif
 }
 #endif
 
@@ -144,9 +147,9 @@ private:
   HANDLE handle_;
 };
 #elif defined(__APPLE__)
-#include <crt_externs.h>
+#  include <crt_externs.h>
 
-#define environ (*_NSGetEnviron())
+#  define environ (*_NSGetEnviron())
 #endif
 
 bool cmSystemTools::s_RunCommandHideConsole = false;
@@ -689,11 +692,11 @@ size_t cmSystemTools::CalculateCommandLineLengthLimit()
     // We estimate the size of the environment block to be 1000.
     // This isn't accurate at all, but leaves some headroom.
     szArgMax = szArgMax < 1000 ? 0 : szArgMax - 1000;
-#if defined(_WIN32) || defined(__linux)
+#  if defined(_WIN32) || defined(__linux)
     sz = std::min(sz, static_cast<size_t>(szArgMax));
-#else
+#  else
     sz = static_cast<size_t>(szArgMax);
-#endif
+#  endif
   }
 #endif
   return sz;
@@ -995,20 +998,20 @@ void cmSystemTools::InitializeLibUV()
   // global _fmode setting so that using libuv does not change the
   // default file text/binary mode.  See libuv issue 840.
   uv_loop_close(uv_default_loop());
-#ifdef _MSC_VER
+#  ifdef _MSC_VER
   _set_fmode(_O_TEXT);
-#else
+#  else
   _fmode = _O_TEXT;
-#endif
+#  endif
 #endif
 }
 
 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
@@ -1460,14 +1463,14 @@ std::string cmSystemTools::CollapseCombinedPath(std::string const& dir,
 #ifdef CMAKE_BUILD_WITH_CMAKE
 bool cmSystemTools::UnsetEnv(const char* value)
 {
-#if !defined(HAVE_UNSETENV)
+#  if !defined(HAVE_UNSETENV)
   std::string var = value;
   var += "=";
   return cmSystemTools::PutEnv(var.c_str());
-#else
+#  else
   unsetenv(value);
   return true;
-#endif
+#  endif
 }
 
 std::vector<std::string> cmSystemTools::GetEnvironmentVariables()
@@ -1513,7 +1516,7 @@ cmSystemTools::SaveRestoreEnvironment::~SaveRestoreEnvironment()
 void cmSystemTools::EnableVSConsoleOutput()
 {
 #ifdef _WIN32
-  // Visual Studio 8 2005 (devenv.exe or VCExpress.exe) will not
+  // Visual Studio tools like devenv may not
   // display output to the console unless this environment variable is
   // set.  We need it to capture the output of these build tools.
   // Note for future work that one could pass "/out \\.\pipe\NAME" to
@@ -1522,13 +1525,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
 }
 
@@ -1599,8 +1602,8 @@ bool cmSystemTools::CreateTar(const char* outFileName,
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
 namespace {
-#define BSDTAR_FILESIZE_PRINTF "%lu"
-#define BSDTAR_FILESIZE_TYPE unsigned long
+#  define BSDTAR_FILESIZE_PRINTF "%lu"
+#  define BSDTAR_FILESIZE_TYPE unsigned long
 void list_item_verbose(FILE* out, struct archive_entry* entry)
 {
   char tmp[100];
@@ -1673,13 +1676,13 @@ void list_item_verbose(FILE* out, struct archive_entry* entry)
 
   /* 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__)
+#  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"
-#else
-#define DAY_FMT "%e" /* Day number without leading zeros */
-#endif
+#    define DAY_FMT "%d"
+#  else
+#    define DAY_FMT "%e" /* Day number without leading zeros */
+#  endif
   if (tim < now - HALF_YEAR || tim > now + HALF_YEAR) {
     fmt = DAY_FMT " %b  %Y";
   } else {
@@ -1700,35 +1703,43 @@ void list_item_verbose(FILE* out, struct archive_entry* entry)
   fflush(out);
 }
 
-long copy_data(struct archive* ar, struct archive* aw)
+// Return 'true' on success
+bool copy_data(struct archive* ar, struct archive* aw)
 {
   long r;
   const void* buff;
   size_t size;
-#if defined(ARCHIVE_VERSION_NUMBER) && ARCHIVE_VERSION_NUMBER >= 3000000
+#  if defined(ARCHIVE_VERSION_NUMBER) && ARCHIVE_VERSION_NUMBER >= 3000000
   __LA_INT64_T offset;
-#else
+#  else
   off_t offset;
-#endif
+#  endif
 
   for (;;) {
+    // Return value:
+    // * ARCHIVE_OK - read succeed
+    // * ARCHIVE_EOF - no more data to read left
     r = archive_read_data_block(ar, &buff, &size, &offset);
     if (r == ARCHIVE_EOF) {
-      return (ARCHIVE_OK);
+      return true;
     }
     if (r != ARCHIVE_OK) {
-      return (r);
+      return false;
     }
-    r = archive_write_data_block(aw, buff, size, offset);
-    if (r != ARCHIVE_OK) {
+    // Return value:
+    // * >= ARCHIVE_OK - write succeed
+    // * < ARCHIVE_OK - write failed
+    const __LA_SSIZE_T w_size =
+      archive_write_data_block(aw, buff, size, offset);
+    if (w_size < ARCHIVE_OK) {
       cmSystemTools::Message("archive_write_data_block()",
                              archive_error_string(aw));
-      return (r);
+      return false;
     }
   }
-#if !defined(__clang__) && !defined(__HP_aCC)
-  return r; /* this should not happen but it quiets some compilers */
-#endif
+#  if !defined(__clang__) && !defined(__HP_aCC)
+  return false; /* this should not happen but it quiets some compilers */
+#  endif
 }
 
 bool extract_tar(const char* outFileName, bool verbose, bool extract)
@@ -1780,7 +1791,10 @@ bool extract_tar(const char* outFileName, bool verbose, bool extract)
 
       r = archive_write_header(ext, entry);
       if (r == ARCHIVE_OK) {
-        copy_data(a, ext);
+        if (!copy_data(a, ext)) {
+          cmSystemTools::Error("Problem with copy_data");
+          break;
+        }
         r = archive_write_finish_entry(ext);
         if (r != ARCHIVE_OK) {
           cmSystemTools::Error("Problem with archive_write_finish_entry(): ",
@@ -1788,13 +1802,13 @@ bool extract_tar(const char* outFileName, bool verbose, bool extract)
           break;
         }
       }
-#ifdef _WIN32
+#  ifdef _WIN32
       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;
       }
-#endif
+#  endif
       else {
         cmSystemTools::Error("Problem with archive_write_header(): ",
                              archive_error_string(ext));
@@ -2041,9 +2055,9 @@ bool cmSystemTools::FileTimeSet(const char* fname, cmSystemToolsFileTime* t)
 }
 
 #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;
@@ -2125,14 +2139,14 @@ void cmSystemTools::FindCMakeResources(const char* argv0)
   exe_dir = cmSystemTools::GetFilenamePath(realPath);
 #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) {
     exe_path = static_cast<char*>(malloc(exe_path_size));
diff --git a/Source/cmSystemTools.h b/Source/cmSystemTools.h
index 4390c863e..c0a1b6b55 100644
--- a/Source/cmSystemTools.h
+++ b/Source/cmSystemTools.h
@@ -333,7 +333,7 @@ public:
   static FileFormat GetFileFormat(const char* ext);
 
   /** Windows if this is true, the CreateProcess in RunCommand will
-   *  not show new consol windows when running programs.
+   *  not show new console windows when running programs.
    */
   static void SetRunCommandHideConsole(bool v) { s_RunCommandHideConsole = v; }
   static bool GetRunCommandHideConsole() { return s_RunCommandHideConsole; }
diff --git a/Source/cmTarget.cxx b/Source/cmTarget.cxx
index cd11c4b14..18688163c 100644
--- a/Source/cmTarget.cxx
+++ b/Source/cmTarget.cxx
@@ -114,15 +114,12 @@ const char* cmTargetPropertyComputer::GetSources<cmTarget>(
         }
         if (!noMessage) {
           e << "Target \"" << tgt->GetName()
-            << "\" 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.";
+            << "\" 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.";
           messenger->IssueMessage(messageType, e.str(), context);
         }
         if (addContent) {
@@ -189,18 +186,10 @@ cmTarget::cmTarget(std::string const& name, cmStateEnums::TargetType type,
   this->ImportedGloballyVisible = vis == VisibilityImportedGlobally;
   this->BuildInterfaceIncludesAppended = false;
 
-  // only add dependency information for library targets
-  if (this->TargetTypeValue >= cmStateEnums::STATIC_LIBRARY &&
-      this->TargetTypeValue <= cmStateEnums::MODULE_LIBRARY) {
-    this->RecordDependencies = true;
-  } else {
-    this->RecordDependencies = false;
-  }
-
   // Check whether this is a DLL platform.
   this->DLLPlatform =
-    (this->Makefile->IsOn("WIN32") || this->Makefile->IsOn("CYGWIN") ||
-     this->Makefile->IsOn("MINGW"));
+    strcmp(this->Makefile->GetSafeDefinition("CMAKE_IMPORT_LIBRARY_SUFFIX"),
+           "") != 0;
 
   // Check whether we are targeting an Android platform.
   this->IsAndroid =
@@ -286,6 +275,7 @@ cmTarget::cmTarget(std::string const& name, cmStateEnums::TargetType type,
     this->SetPropertyDefault("CUDA_SEPARABLE_COMPILATION", nullptr);
     this->SetPropertyDefault("LINK_SEARCH_START_STATIC", nullptr);
     this->SetPropertyDefault("LINK_SEARCH_END_STATIC", nullptr);
+    this->SetPropertyDefault("FOLDER", nullptr);
   }
 
   // Collect the set of configuration types.
@@ -409,6 +399,10 @@ cmTarget::cmTarget(std::string const& name, cmStateEnums::TargetType type,
     this->SetPropertyDefault("JOB_POOL_COMPILE", nullptr);
     this->SetPropertyDefault("JOB_POOL_LINK", nullptr);
   }
+
+  if (this->TargetTypeValue <= cmStateEnums::UTILITY) {
+    this->SetPropertyDefault("DOTNET_TARGET_FRAMEWORK_VERSION", nullptr);
+  }
 }
 
 cmGlobalGenerator* cmTarget::GetGlobalGenerator() const
@@ -509,7 +503,7 @@ std::string cmTarget::ProcessSourceItemCMP0049(const std::string& s)
 {
   std::string src = s;
 
-  // For backwards compatibility replace varibles in source names.
+  // For backwards compatibility replace variables in source names.
   // This should eventually be removed.
   this->Makefile->ExpandVariablesInString(src);
   if (src != s) {
@@ -638,27 +632,11 @@ 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)
 {
-  // Clear the dependencies. The cache variable must exist iff we are
-  // recording dependency information for this target.
-  std::string depname = target;
+  std::string depname = this->GetName();
   depname += "_LIB_DEPENDS";
-  if (this->RecordDependencies) {
-    mf.AddCacheDefinition(depname, "", "Dependencies for target",
-                          cmStateEnums::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());
-    }
-  }
+  mf.RemoveCacheDefinition(depname);
 }
 
 std::string cmTarget::GetDebugGeneratorExpressions(
@@ -742,19 +720,16 @@ void cmTarget::AddLinkLibrary(cmMakefile& mf, const std::string& lib,
   }
 
   if (cmGeneratorExpression::Find(lib) != std::string::npos ||
-      (tgt && tgt->GetType() == cmStateEnums::INTERFACE_LIBRARY) ||
+      (tgt &&
+       (tgt->GetType() == cmStateEnums::INTERFACE_LIBRARY ||
+        tgt->GetType() == cmStateEnums::OBJECT_LIBRARY)) ||
       (this->Name == lib)) {
     return;
   }
 
-  {
-    cmTarget::LibraryID tmp;
-    tmp.first = lib;
-    tmp.second = llt;
-    this->OriginalLinkLibraries.emplace_back(lib, llt);
-  }
+  this->OriginalLinkLibraries.emplace_back(lib, llt);
 
-  // Add the explicit dependency information for this target. This is
+  // Add the explicit dependency information for libraries. This is
   // simply a set of libraries separated by ";". There should always
   // be a trailing ";". These library names are not canonical, in that
   // they may be "-framework x", "-ly", "/path/libz.a", etc.
@@ -762,7 +737,10 @@ void cmTarget::AddLinkLibrary(cmMakefile& mf, const std::string& lib,
   // 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->TargetTypeValue >= cmStateEnums::STATIC_LIBRARY &&
+      this->TargetTypeValue <= cmStateEnums::MODULE_LIBRARY &&
+      (this->GetPolicyStatusCMP0073() == cmPolicies::OLD ||
+       this->GetPolicyStatusCMP0073() == cmPolicies::WARN)) {
     std::string targetEntry = this->Name;
     targetEntry += "_LIB_DEPENDS";
     std::string dependencies;
@@ -1535,22 +1513,24 @@ bool cmTarget::CheckImportedLibName(std::string const& prop,
   if (this->GetType() != cmStateEnums::INTERFACE_LIBRARY ||
       !this->IsImported()) {
     this->Makefile->IssueMessage(
-      cmake::FATAL_ERROR, prop +
+      cmake::FATAL_ERROR,
+      prop +
         " property may be set only on imported INTERFACE library targets.");
     return false;
   }
   if (!value.empty()) {
     if (value[0] == '-') {
-      this->Makefile->IssueMessage(cmake::FATAL_ERROR, prop +
-                                     " property value\n  " + value +
+      this->Makefile->IssueMessage(cmake::FATAL_ERROR,
+                                   prop + " property value\n  " + value +
                                      "\nmay not start with '-'.");
       return false;
     }
     std::string::size_type bad = value.find_first_of(":/\\;");
     if (bad != std::string::npos) {
-      this->Makefile->IssueMessage(
-        cmake::FATAL_ERROR, prop + " property value\n  " + value +
-          "\nmay not contain '" + value.substr(bad, 1) + "'.");
+      this->Makefile->IssueMessage(cmake::FATAL_ERROR,
+                                   prop + " property value\n  " + value +
+                                     "\nmay not contain '" +
+                                     value.substr(bad, 1) + "'.");
       return false;
     }
   }
diff --git a/Source/cmTarget.h b/Source/cmTarget.h
index 56f3e3a04..3abb47ed1 100644
--- a/Source/cmTarget.h
+++ b/Source/cmTarget.h
@@ -36,6 +36,7 @@ public:
   cmTargetInternalPointer& operator=(cmTargetInternalPointer const& r);
   cmTargetInternals* operator->() const { return this->Pointer; }
   cmTargetInternals* Get() const { return this->Pointer; }
+
 private:
   cmTargetInternals* Pointer;
 };
@@ -137,7 +138,7 @@ public:
   /**
    * Clear the dependency information recorded for this target, if any.
    */
-  void ClearDependencyInformation(cmMakefile& mf, const std::string& target);
+  void ClearDependencyInformation(cmMakefile& mf);
 
   void AddLinkLibrary(cmMakefile& mf, const std::string& lib,
                       cmTargetLinkLibraryType llt);
@@ -181,8 +182,8 @@ public:
   void SetHaveInstallRule(bool h) { this->HaveInstallRule = h; }
 
   /**
-  * Get/Set whether this target was auto-created by a generator.
-  */
+   * Get/Set whether this target was auto-created by a generator.
+   */
   bool GetIsGeneratorProvided() const { return this->IsGeneratorProvided; }
   void SetIsGeneratorProvided(bool igp) { this->IsGeneratorProvided = igp; }
 
@@ -310,7 +311,6 @@ private:
   cmTargetInternalPointer Internal;
   cmStateEnums::TargetType TargetTypeValue;
   bool HaveInstallRule;
-  bool RecordDependencies;
   bool DLLPlatform;
   bool IsAndroid;
   bool IsImportedTarget;
diff --git a/Source/cmTargetLinkLibrariesCommand.cxx b/Source/cmTargetLinkLibrariesCommand.cxx
index 9e4575a69..1bbcf4692 100644
--- a/Source/cmTargetLinkLibrariesCommand.cxx
+++ b/Source/cmTargetLinkLibrariesCommand.cxx
@@ -94,16 +94,6 @@ bool cmTargetLinkLibrariesCommand::InitialPass(
     return true;
   }
 
-  // OBJECT libraries are not allowed on the LHS of the command.
-  if (this->Target->GetType() == cmStateEnums::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;
-  }
-
   // Having a UTILITY library on the LHS is a bug.
   if (this->Target->GetType() == cmStateEnums::UTILITY) {
     std::ostringstream e;
@@ -352,8 +342,9 @@ bool cmTargetLinkLibrariesCommand::HandleLibrary(const std::string& lib,
       // 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 \""
+      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";
@@ -401,14 +392,15 @@ bool cmTargetLinkLibrariesCommand::HandleLibrary(const std::string& lib,
     if (tgt && (tgt->GetType() != cmStateEnums::STATIC_LIBRARY) &&
         (tgt->GetType() != cmStateEnums::SHARED_LIBRARY) &&
         (tgt->GetType() != cmStateEnums::UNKNOWN_LIBRARY) &&
+        (tgt->GetType() != cmStateEnums::OBJECT_LIBRARY) &&
         (tgt->GetType() != cmStateEnums::INTERFACE_LIBRARY) &&
         !tgt->IsExecutableWithExports()) {
       std::ostringstream e;
       e << "Target \"" << lib << "\" of type "
         << cmState::GetTargetTypeName(tgt->GetType())
         << " may not be linked into another target.  One may link only to "
-           "INTERFACE, STATIC or SHARED libraries, or to executables with the "
-           "ENABLE_EXPORTS property set.";
+           "INTERFACE, OBJECT, STATIC or SHARED libraries, or to executables "
+           "with the ENABLE_EXPORTS property set.";
       this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
     }
 
diff --git a/Source/cmTargetLinkLibrariesCommand.h b/Source/cmTargetLinkLibrariesCommand.h
index a2f3ecd4d..54f8cf4b8 100644
--- a/Source/cmTargetLinkLibrariesCommand.h
+++ b/Source/cmTargetLinkLibrariesCommand.h
@@ -43,7 +43,7 @@ private:
   void LinkLibraryTypeSpecifierWarning(int left, int right);
   static const char* LinkLibraryTypeNames[3];
 
-  cmTarget* Target;
+  cmTarget* Target = nullptr;
   enum ProcessingState
   {
     ProcessingLinkLibraries,
@@ -55,7 +55,7 @@ private:
     ProcessingKeywordPrivateInterface
   };
 
-  ProcessingState CurrentProcessingState;
+  ProcessingState CurrentProcessingState = ProcessingLinkLibraries;
 
   bool HandleLibrary(const std::string& lib, cmTargetLinkLibraryType llt);
 };
diff --git a/Source/cmTargetPropCommandBase.h b/Source/cmTargetPropCommandBase.h
index 3c736fc0d..943285df1 100644
--- a/Source/cmTargetPropCommandBase.h
+++ b/Source/cmTargetPropCommandBase.h
@@ -28,7 +28,7 @@ public:
 
 protected:
   std::string Property;
-  cmTarget* Target;
+  cmTarget* Target = nullptr;
 
   virtual void HandleInterfaceContent(cmTarget* tgt,
                                       const std::vector<std::string>& content,
diff --git a/Source/cmTestGenerator.cxx b/Source/cmTestGenerator.cxx
index b5483593e..c532efb81 100644
--- a/Source/cmTestGenerator.cxx
+++ b/Source/cmTestGenerator.cxx
@@ -111,8 +111,9 @@ void cmTestGenerator::GenerateScriptForConfig(std::ostream& os,
   os << cmOutputConverter::EscapeForCMake(exe);
   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));
+    os << " "
+       << cmOutputConverter::EscapeForCMake(
+            ge.Parse(*ci)->Evaluate(this->LG, config));
   }
 
   // Finish the test command.
diff --git a/Source/cmUVHandlePtr.cxx b/Source/cmUVHandlePtr.cxx
index eb70416c7..fd07d2dba 100644
--- a/Source/cmUVHandlePtr.cxx
+++ b/Source/cmUVHandlePtr.cxx
@@ -87,16 +87,16 @@ template <>
 struct uv_handle_deleter<uv_async_t>
 {
   /***
-  * Wile uv_async_send is itself thread-safe, there are
-  * no strong guarantees that close hasn't already been
-  * called on the handle; and that it might be deleted
-  * as the send call goes through. This mutex guards
-  * against that.
-  *
-  * The shared_ptr here is to allow for copy construction
-  * which is mandated by the standard for Deleter on
-  * shared_ptrs.
-  */
+   * Wile uv_async_send is itself thread-safe, there are
+   * no strong guarantees that close hasn't already been
+   * called on the handle; and that it might be deleted
+   * as the send call goes through. This mutex guards
+   * against that.
+   *
+   * The shared_ptr here is to allow for copy construction
+   * which is mandated by the standard for Deleter on
+   * shared_ptrs.
+   */
   std::shared_ptr<std::mutex> handleMutex;
 
   uv_handle_deleter()
diff --git a/Source/cmUVHandlePtr.h b/Source/cmUVHandlePtr.h
index a6ce565c9..2937e0d1a 100644
--- a/Source/cmUVHandlePtr.h
+++ b/Source/cmUVHandlePtr.h
@@ -21,12 +21,12 @@
 namespace cm {
 
 /***
-* RAII class to simplify and insure the safe usage of uv_*_t types. This
-* includes making sure resources are properly freed and contains casting
-* operators which allow for passing into relevant uv_* functions.
-*
-*@tparam T actual uv_*_t type represented.
-*/
+ * RAII class to simplify and insure the safe usage of uv_*_t types. This
+ * includes making sure resources are properly freed and contains casting
+ * operators which allow for passing into relevant uv_* functions.
+ *
+ *@tparam T actual uv_*_t type represented.
+ */
 template <typename T>
 class uv_handle_ptr_base_
 {
@@ -65,8 +65,9 @@ public:
    * that initializes something like uv_pipe_ptr or uv_tcp_ptr and interact
    * and clean up after it without caring about the exact type.
    */
-  template <typename S, typename = typename std::enable_if<
-                          std::is_rvalue_reference<S&&>::value>::type>
+  template <typename S,
+            typename = typename std::enable_if<
+              std::is_rvalue_reference<S&&>::value>::type>
   uv_handle_ptr_base_(S&& rhs)
   {
     // This will force a compiler error if rhs doesn't have a casting
@@ -198,9 +199,9 @@ typedef uv_handle_ptr_<uv_handle_t> uv_handle_ptr;
 
 extern template class uv_handle_ptr_base_<uv_handle_t>;
 
-#define UV_HANDLE_PTR_INSTANTIATE_EXTERN(NAME)                                \
-  extern template class uv_handle_ptr_base_<uv_##NAME##_t>;                   \
-  extern template class uv_handle_ptr_<uv_##NAME##_t>;
+#  define UV_HANDLE_PTR_INSTANTIATE_EXTERN(NAME)                              \
+    extern template class uv_handle_ptr_base_<uv_##NAME##_t>;                 \
+    extern template class uv_handle_ptr_<uv_##NAME##_t>;
 
 UV_HANDLE_PTR_INSTANTIATE_EXTERN(async)
 
@@ -216,7 +217,7 @@ UV_HANDLE_PTR_INSTANTIATE_EXTERN(timer)
 
 UV_HANDLE_PTR_INSTANTIATE_EXTERN(tty)
 
-#undef UV_HANDLE_PTR_INSTANTIATE_EXTERN
+#  undef UV_HANDLE_PTR_INSTANTIATE_EXTERN
 
 #endif
 }
diff --git a/Source/cmUVSignalHackRAII.h b/Source/cmUVSignalHackRAII.h
index c019aea8e..63599db82 100644
--- a/Source/cmUVSignalHackRAII.h
+++ b/Source/cmUVSignalHackRAII.h
@@ -7,8 +7,8 @@
 
 #if defined(CMAKE_USE_SYSTEM_LIBUV) && !defined(_WIN32) &&                    \
   UV_VERSION_MAJOR == 1 && UV_VERSION_MINOR < 19
-#define CMAKE_UV_SIGNAL_HACK
-#include "cmUVHandlePtr.h"
+#  define CMAKE_UV_SIGNAL_HACK
+#  include "cmUVHandlePtr.h"
 /*
    libuv does not use SA_RESTART on its signal handler, but C++ streams
    depend on it for reliable i/o operations.  This RAII helper convinces
@@ -22,6 +22,7 @@ class cmUVSignalHackRAII
   uv_loop_t HackLoop;
   cm::uv_signal_ptr HackSignal;
   static void HackCB(uv_signal_t*, int) {}
+
 public:
   cmUVSignalHackRAII()
   {
diff --git a/Source/cmUtilitySourceCommand.cxx b/Source/cmUtilitySourceCommand.cxx
index 114080090..a60163719 100644
--- a/Source/cmUtilitySourceCommand.cxx
+++ b/Source/cmUtilitySourceCommand.cxx
@@ -44,11 +44,11 @@ bool cmUtilitySourceCommand::InitialPass(std::vector<std::string> const& args,
     }
   } else {
     cmState* state = this->Makefile->GetState();
-    haveCacheValue =
-      (cacheValue && (strstr(cacheValue, "(IntDir)") == nullptr ||
-                      (intDir && strcmp(intDir, "$(IntDir)") == 0)) &&
-       (state->GetCacheMajorVersion() != 0 &&
-        state->GetCacheMinorVersion() != 0));
+    haveCacheValue = (cacheValue &&
+                      (strstr(cacheValue, "(IntDir)") == nullptr ||
+                       (intDir && strcmp(intDir, "$(IntDir)") == 0)) &&
+                      (state->GetCacheMajorVersion() != 0 &&
+                       state->GetCacheMinorVersion() != 0));
   }
 
   if (haveCacheValue) {
diff --git a/Source/cmVS10CudaFlagTable.h b/Source/cmVS10CudaFlagTable.h
index da19d649b..2b57e08ab 100644
--- a/Source/cmVS10CudaFlagTable.h
+++ b/Source/cmVS10CudaFlagTable.h
@@ -47,5 +47,8 @@ static cmVS7FlagTable cmVS10CudaFlagTable[] = {
   { "HostDebugInfo", "g", "", "true", 0 },
   { "HostDebugInfo", "-debug", "", "true", 0 },
 
+  { "MaxRegCount", "maxrregcount=", "", "", cmVS7FlagTable::UserValue },
+  { "MaxRegCount", "maxrregcount", "", "", cmVS7FlagTable::UserFollowing },
+
   { 0, 0, 0, 0, 0 }
 };
diff --git a/Source/cmVS10LibFlagTable.h b/Source/cmVS10LibFlagTable.h
index 65f28ef40..be4f4753b 100644
--- a/Source/cmVS10LibFlagTable.h
+++ b/Source/cmVS10LibFlagTable.h
@@ -49,11 +49,11 @@ static cmVS7FlagTable cmVS10LibFlagTable[] = {
 
   // String List Properties
   // Skip [AdditionalDependencies] - no command line Switch.
-  { "AdditionalLibraryDirectories", "LIBPATH:",
-    "Additional Library Directories", "",
+  { "AdditionalLibraryDirectories",
+    "LIBPATH:", "Additional Library Directories", "",
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
-  { "IgnoreSpecificDefaultLibraries", "NODEFAULTLIB:",
-    "Ignore Specific Default Libraries", "",
+  { "IgnoreSpecificDefaultLibraries",
+    "NODEFAULTLIB:", "Ignore Specific Default Libraries", "",
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
   { "ExportNamedFunctions", "EXPORT:", "Export Named Functions", "",
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
diff --git a/Source/cmVS10LinkFlagTable.h b/Source/cmVS10LinkFlagTable.h
index 6a0313a2f..8f5b59b03 100644
--- a/Source/cmVS10LinkFlagTable.h
+++ b/Source/cmVS10LinkFlagTable.h
@@ -176,17 +176,17 @@ static cmVS7FlagTable cmVS10LinkFlagTable[] = {
     cmVS7FlagTable::UserValueRequired },
 
   // String List Properties
-  { "AdditionalLibraryDirectories", "LIBPATH:",
-    "Additional Library Directories", "",
+  { "AdditionalLibraryDirectories",
+    "LIBPATH:", "Additional Library Directories", "",
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
   // Skip [AdditionalDependencies] - no command line Switch.
-  { "IgnoreSpecificDefaultLibraries", "NODEFAULTLIB:",
-    "Ignore Specific Default Libraries", "",
+  { "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", "",
+  { "EmbedManagedResourceFile",
+    "ASSEMBLYRESOURCE:", "Embed Managed Resource File", "",
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
   { "ForceSymbolReferences", "INCLUDE:", "Force Symbol References", "",
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
@@ -194,8 +194,8 @@ static cmVS7FlagTable cmVS10LinkFlagTable[] = {
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
   { "AssemblyLinkResource", "ASSEMBLYLINKRESOURCE:", "Assembly Link Resource",
     "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
-  { "AdditionalManifestDependencies", "MANIFESTDEPENDENCY:",
-    "Additional Manifest Dependencies", "",
+  { "AdditionalManifestDependencies",
+    "MANIFESTDEPENDENCY:", "Additional Manifest Dependencies", "",
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
 
   // String Properties
diff --git a/Source/cmVS11LibFlagTable.h b/Source/cmVS11LibFlagTable.h
index 8aacaacd3..15c8ddda3 100644
--- a/Source/cmVS11LibFlagTable.h
+++ b/Source/cmVS11LibFlagTable.h
@@ -49,11 +49,11 @@ static cmVS7FlagTable cmVS11LibFlagTable[] = {
 
   // String List Properties
   // Skip [AdditionalDependencies] - no command line Switch.
-  { "AdditionalLibraryDirectories", "LIBPATH:",
-    "Additional Library Directories", "",
+  { "AdditionalLibraryDirectories",
+    "LIBPATH:", "Additional Library Directories", "",
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
-  { "IgnoreSpecificDefaultLibraries", "NODEFAULTLIB:",
-    "Ignore Specific Default Libraries", "",
+  { "IgnoreSpecificDefaultLibraries",
+    "NODEFAULTLIB:", "Ignore Specific Default Libraries", "",
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
   { "ExportNamedFunctions", "EXPORT:", "Export Named Functions", "",
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
diff --git a/Source/cmVS11LinkFlagTable.h b/Source/cmVS11LinkFlagTable.h
index 24ba8fded..53f11392f 100644
--- a/Source/cmVS11LinkFlagTable.h
+++ b/Source/cmVS11LinkFlagTable.h
@@ -193,17 +193,17 @@ static cmVS7FlagTable cmVS11LinkFlagTable[] = {
     cmVS7FlagTable::UserValueRequired },
 
   // String List Properties
-  { "AdditionalLibraryDirectories", "LIBPATH:",
-    "Additional Library Directories", "",
+  { "AdditionalLibraryDirectories",
+    "LIBPATH:", "Additional Library Directories", "",
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
   // Skip [AdditionalDependencies] - no command line Switch.
-  { "IgnoreSpecificDefaultLibraries", "NODEFAULTLIB:",
-    "Ignore Specific Default Libraries", "",
+  { "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", "",
+  { "EmbedManagedResourceFile",
+    "ASSEMBLYRESOURCE:", "Embed Managed Resource File", "",
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
   { "ForceSymbolReferences", "INCLUDE:", "Force Symbol References", "",
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
@@ -211,8 +211,8 @@ static cmVS7FlagTable cmVS11LinkFlagTable[] = {
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
   { "AssemblyLinkResource", "ASSEMBLYLINKRESOURCE:", "Assembly Link Resource",
     "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
-  { "AdditionalManifestDependencies", "MANIFESTDEPENDENCY:",
-    "Additional Manifest Dependencies", "",
+  { "AdditionalManifestDependencies",
+    "MANIFESTDEPENDENCY:", "Additional Manifest Dependencies", "",
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
   { "ManifestInput", "manifestinput:", "Manifest Input", "",
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
diff --git a/Source/cmVS12LibFlagTable.h b/Source/cmVS12LibFlagTable.h
index 0f7a25955..2229b97da 100644
--- a/Source/cmVS12LibFlagTable.h
+++ b/Source/cmVS12LibFlagTable.h
@@ -49,11 +49,11 @@ static cmVS7FlagTable cmVS12LibFlagTable[] = {
 
   // String List Properties
   // Skip [AdditionalDependencies] - no command line Switch.
-  { "AdditionalLibraryDirectories", "LIBPATH:",
-    "Additional Library Directories", "",
+  { "AdditionalLibraryDirectories",
+    "LIBPATH:", "Additional Library Directories", "",
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
-  { "IgnoreSpecificDefaultLibraries", "NODEFAULTLIB:",
-    "Ignore Specific Default Libraries", "",
+  { "IgnoreSpecificDefaultLibraries",
+    "NODEFAULTLIB:", "Ignore Specific Default Libraries", "",
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
   { "ExportNamedFunctions", "EXPORT:", "Export Named Functions", "",
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
diff --git a/Source/cmVS12LinkFlagTable.h b/Source/cmVS12LinkFlagTable.h
index fc667c359..ddc3ea191 100644
--- a/Source/cmVS12LinkFlagTable.h
+++ b/Source/cmVS12LinkFlagTable.h
@@ -193,17 +193,17 @@ static cmVS7FlagTable cmVS12LinkFlagTable[] = {
     cmVS7FlagTable::UserValueRequired },
 
   // String List Properties
-  { "AdditionalLibraryDirectories", "LIBPATH:",
-    "Additional Library Directories", "",
+  { "AdditionalLibraryDirectories",
+    "LIBPATH:", "Additional Library Directories", "",
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
   // Skip [AdditionalDependencies] - no command line Switch.
-  { "IgnoreSpecificDefaultLibraries", "NODEFAULTLIB:",
-    "Ignore Specific Default Libraries", "",
+  { "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", "",
+  { "EmbedManagedResourceFile",
+    "ASSEMBLYRESOURCE:", "Embed Managed Resource File", "",
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
   { "ForceSymbolReferences", "INCLUDE:", "Force Symbol References", "",
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
@@ -211,8 +211,8 @@ static cmVS7FlagTable cmVS12LinkFlagTable[] = {
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
   { "AssemblyLinkResource", "ASSEMBLYLINKRESOURCE:", "Assembly Link Resource",
     "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
-  { "AdditionalManifestDependencies", "MANIFESTDEPENDENCY:",
-    "Additional Manifest Dependencies", "",
+  { "AdditionalManifestDependencies",
+    "MANIFESTDEPENDENCY:", "Additional Manifest Dependencies", "",
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
   { "ManifestInput", "manifestinput:", "Manifest Input", "",
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
diff --git a/Source/cmVS140LinkFlagTable.h b/Source/cmVS140LinkFlagTable.h
index 7c9452abf..fe0315386 100644
--- a/Source/cmVS140LinkFlagTable.h
+++ b/Source/cmVS140LinkFlagTable.h
@@ -204,19 +204,19 @@ static cmVS7FlagTable cmVS140LinkFlagTable[] = {
     cmVS7FlagTable::UserValueRequired },
 
   // String List Properties
-  { "AdditionalLibraryDirectories", "LIBPATH:",
-    "Additional Library Directories", "",
+  { "AdditionalLibraryDirectories",
+    "LIBPATH:", "Additional Library Directories", "",
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
   { "Natvis", "NATVIS:", "Natvis files", "",
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
   // Skip [AdditionalDependencies] - no command line Switch.
-  { "IgnoreSpecificDefaultLibraries", "NODEFAULTLIB:",
-    "Ignore Specific Default Libraries", "",
+  { "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", "",
+  { "EmbedManagedResourceFile",
+    "ASSEMBLYRESOURCE:", "Embed Managed Resource File", "",
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
   { "ForceSymbolReferences", "INCLUDE:", "Force Symbol References", "",
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
@@ -224,8 +224,8 @@ static cmVS7FlagTable cmVS140LinkFlagTable[] = {
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
   { "AssemblyLinkResource", "ASSEMBLYLINKRESOURCE:", "Assembly Link Resource",
     "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
-  { "AdditionalManifestDependencies", "MANIFESTDEPENDENCY:",
-    "Additional Manifest Dependencies", "",
+  { "AdditionalManifestDependencies",
+    "MANIFESTDEPENDENCY:", "Additional Manifest Dependencies", "",
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
   { "ManifestInput", "manifestinput:", "Manifest Input", "",
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
diff --git a/Source/cmVS141LinkFlagTable.h b/Source/cmVS141LinkFlagTable.h
index f159f7061..7e56c8e80 100644
--- a/Source/cmVS141LinkFlagTable.h
+++ b/Source/cmVS141LinkFlagTable.h
@@ -206,19 +206,19 @@ static cmVS7FlagTable cmVS141LinkFlagTable[] = {
     cmVS7FlagTable::UserValueRequired },
 
   // String List Properties
-  { "AdditionalLibraryDirectories", "LIBPATH:",
-    "Additional Library Directories", "",
+  { "AdditionalLibraryDirectories",
+    "LIBPATH:", "Additional Library Directories", "",
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
   { "Natvis", "NATVIS:", "Natvis files", "",
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
   // Skip [AdditionalDependencies] - no command line Switch.
-  { "IgnoreSpecificDefaultLibraries", "NODEFAULTLIB:",
-    "Ignore Specific Default Libraries", "",
+  { "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", "",
+  { "EmbedManagedResourceFile",
+    "ASSEMBLYRESOURCE:", "Embed Managed Resource File", "",
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
   { "ForceSymbolReferences", "INCLUDE:", "Force Symbol References", "",
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
@@ -226,8 +226,8 @@ static cmVS7FlagTable cmVS141LinkFlagTable[] = {
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
   { "AssemblyLinkResource", "ASSEMBLYLINKRESOURCE:", "Assembly Link Resource",
     "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
-  { "AdditionalManifestDependencies", "MANIFESTDEPENDENCY:",
-    "Additional Manifest Dependencies", "",
+  { "AdditionalManifestDependencies",
+    "MANIFESTDEPENDENCY:", "Additional Manifest Dependencies", "",
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
   { "ManifestInput", "manifestinput:", "Manifest Input", "",
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
diff --git a/Source/cmVS14LibFlagTable.h b/Source/cmVS14LibFlagTable.h
index be4652c68..adce075fb 100644
--- a/Source/cmVS14LibFlagTable.h
+++ b/Source/cmVS14LibFlagTable.h
@@ -50,11 +50,11 @@ static cmVS7FlagTable cmVS14LibFlagTable[] = {
 
   // String List Properties
   // Skip [AdditionalDependencies] - no command line Switch.
-  { "AdditionalLibraryDirectories", "LIBPATH:",
-    "Additional Library Directories", "",
+  { "AdditionalLibraryDirectories",
+    "LIBPATH:", "Additional Library Directories", "",
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
-  { "IgnoreSpecificDefaultLibraries", "NODEFAULTLIB:",
-    "Ignore Specific Default Libraries", "",
+  { "IgnoreSpecificDefaultLibraries",
+    "NODEFAULTLIB:", "Ignore Specific Default Libraries", "",
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
   { "ExportNamedFunctions", "EXPORT:", "Export Named Functions", "",
     cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
diff --git a/Source/cmVSSetupHelper.cxx b/Source/cmVSSetupHelper.cxx
index c2f8debc8..22fe007ba 100644
--- a/Source/cmVSSetupHelper.cxx
+++ b/Source/cmVSSetupHelper.cxx
@@ -7,7 +7,7 @@
 #include "cmsys/FStream.hxx"
 
 #ifndef VSSetupConstants
-#define VSSetupConstants
+#  define VSSetupConstants
 /* clang-format off */
 const IID IID_ISetupConfiguration = {
   0x42843719, 0xDB4C, 0x46C2,
@@ -199,6 +199,7 @@ bool cmVSSetupAPIHelper::GetVSInstanceInfo(
     if (!cmSystemTools::FileIsDirectory(vcToolsDir)) {
       return false;
     }
+    vsInstanceInfo.VCToolsetVersion = vcToolsVersion;
   }
 
   // Reboot may have been required before the product package was registered
@@ -254,6 +255,18 @@ bool cmVSSetupAPIHelper::GetVSInstanceInfo(std::string& vsInstallLocation)
   return isInstalled;
 }
 
+bool cmVSSetupAPIHelper::GetVCToolsetVersion(std::string& vsToolsetVersion)
+{
+  vsToolsetVersion.clear();
+  bool isInstalled = this->EnumerateAndChooseVSInstance();
+
+  if (isInstalled) {
+    vsToolsetVersion = chosenInstanceInfo.VCToolsetVersion;
+  }
+
+  return isInstalled && !vsToolsetVersion.empty();
+}
+
 bool cmVSSetupAPIHelper::EnumerateAndChooseVSInstance()
 {
   bool isVSInstanceExists = false;
diff --git a/Source/cmVSSetupHelper.h b/Source/cmVSSetupHelper.h
index c07cfafc2..4144c1541 100644
--- a/Source/cmVSSetupHelper.h
+++ b/Source/cmVSSetupHelper.h
@@ -4,7 +4,7 @@
 #define cmVSSetupHelper_h
 
 #ifndef NOMINMAX
-#define NOMINMAX // Undefine min and max defined by windows.h
+#  define NOMINMAX // Undefine min and max defined by windows.h
 #endif
 
 // Published by Visual Studio Setup team
@@ -97,6 +97,7 @@ public:
   operator BSTR() const { return str; }
   BSTR* operator&() throw() { return &str; }
   ~SmartBSTR() throw() { ::SysFreeString(str); }
+
 private:
   BSTR str;
 };
@@ -106,16 +107,12 @@ struct VSInstanceInfo
   std::wstring InstanceId;
   std::wstring VSInstallLocation;
   std::wstring Version;
-  ULONGLONG ullVersion;
-  bool IsWin10SDKInstalled;
-  bool IsWin81SDKInstalled;
+  std::string VCToolsetVersion;
+  ULONGLONG ullVersion = 0;
+  bool IsWin10SDKInstalled = false;
+  bool IsWin81SDKInstalled = false;
 
-  VSInstanceInfo()
-  {
-    InstanceId = VSInstallLocation = Version = L"";
-    ullVersion = 0;
-    IsWin10SDKInstalled = IsWin81SDKInstalled = false;
-  }
+  VSInstanceInfo() = default;
 
   std::string GetInstallLocation() const;
 };
@@ -130,6 +127,7 @@ public:
 
   bool IsVS2017Installed();
   bool GetVSInstanceInfo(std::string& vsInstallLocation);
+  bool GetVCToolsetVersion(std::string& vsToolsetVersion);
   bool IsWin10SDKInstalled();
   bool IsWin81SDKInstalled();
 
diff --git a/Source/cmVersionMacros.h b/Source/cmVersionMacros.h
index 1b617bd2b..e8ac4f862 100644
--- a/Source/cmVersionMacros.h
+++ b/Source/cmVersionMacros.h
@@ -7,7 +7,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 8a9df8f94..eff915b47 100644
--- a/Source/cmVisualStudio10TargetGenerator.cxx
+++ b/Source/cmVisualStudio10TargetGenerator.cxx
@@ -8,7 +8,7 @@
 #include "cmGeneratedFileStream.h"
 #include "cmGeneratorTarget.h"
 #include "cmGlobalVisualStudio10Generator.h"
-#include "cmLocalVisualStudio7Generator.h"
+#include "cmLocalVisualStudio10Generator.h"
 #include "cmMakefile.h"
 #include "cmSourceFile.h"
 #include "cmSystemTools.h"
@@ -28,12 +28,158 @@ static std::string cmVS10EscapeXML(std::string arg)
   return arg;
 }
 
-static std::string cmVS10EscapeQuotes(std::string arg)
+static std::string cmVS10EscapeAttr(std::string arg)
 {
+  cmSystemTools::ReplaceString(arg, "&", "&amp;");
+  cmSystemTools::ReplaceString(arg, "<", "&lt;");
+  cmSystemTools::ReplaceString(arg, ">", "&gt;");
   cmSystemTools::ReplaceString(arg, "\"", "&quot;");
   return arg;
 }
 
+struct cmVisualStudio10TargetGenerator::Elem
+{
+  std::ostream& S;
+  const int Indent;
+  bool HasElements = false;
+  bool HasContent = false;
+  std::string Tag;
+
+  Elem(std::ostream& s)
+    : S(s)
+    , Indent(0)
+  {
+  }
+  Elem(const Elem&) = delete;
+  Elem(Elem& par)
+    : S(par.S)
+    , Indent(par.Indent + 1)
+  {
+    par.SetHasElements();
+  }
+  Elem(Elem& par, const char* tag)
+    : S(par.S)
+    , Indent(par.Indent + 1)
+  {
+    par.SetHasElements();
+    this->StartElement(tag);
+  }
+  void SetHasElements()
+  {
+    if (!HasElements) {
+      this->S << ">\n";
+      HasElements = true;
+    }
+  }
+  std::ostream& WriteString(const char* line);
+  Elem& StartElement(const std::string& tag)
+  {
+    this->Tag = tag;
+    this->WriteString("<") << tag;
+    return *this;
+  }
+  void Element(const char* tag, const std::string& val)
+  {
+    Elem(*this, tag).Content(val);
+  }
+  Elem& Attribute(const char* an, const std::string& av)
+  {
+    this->S << " " << an << "=\"" << cmVS10EscapeAttr(av) << "\"";
+    return *this;
+  }
+  // This method for now assumes that this->Tag has been set, e.g. by calling
+  // StartElement().
+  void Content(const std::string& val)
+  {
+    if (!this->HasContent) {
+      this->S << ">";
+      this->HasContent = true;
+    }
+    this->S << cmVS10EscapeXML(val);
+  }
+  ~Elem()
+  {
+    // Do not emit element which has not been started
+    if (Tag.empty()) {
+      return;
+    }
+
+    if (HasElements) {
+      this->WriteString("</") << this->Tag << ">";
+      if (this->Indent > 0) {
+        this->S << '\n';
+      } else {
+        // special case: don't print EOL at EOF
+      }
+    } else if (HasContent) {
+      this->S << "</" << this->Tag << ">\n";
+    } else {
+      this->S << " />\n";
+    }
+  }
+
+  void WritePlatformConfigTag(const char* tag, const std::string& cond,
+                              const std::string& content);
+};
+
+class cmVS10GeneratorOptions : public cmVisualStudioGeneratorOptions
+{
+public:
+  typedef cmVisualStudio10TargetGenerator::Elem Elem;
+  cmVS10GeneratorOptions(cmLocalVisualStudioGenerator* lg, Tool tool,
+                         cmVS7FlagTable const* table,
+                         cmVisualStudio10TargetGenerator* g = nullptr)
+    : cmVisualStudioGeneratorOptions(lg, tool, table)
+    , TargetGenerator(g)
+  {
+  }
+
+  void OutputFlag(std::ostream& /*fout*/, int /*indent*/, const char* tag,
+                  const std::string& content) override
+  {
+    if (!this->GetConfiguration().empty()) {
+      // if there are configuration specific flags, then
+      // use the configuration specific tag for PreprocessorDefinitions
+      const std::string cond =
+        this->TargetGenerator->CalcCondition(this->GetConfiguration());
+      this->Parent->WritePlatformConfigTag(tag, cond, content);
+    } else {
+      this->Parent->Element(tag, content);
+    }
+  }
+
+private:
+  cmVisualStudio10TargetGenerator* const TargetGenerator;
+  Elem* Parent = nullptr;
+  friend cmVisualStudio10TargetGenerator::OptionsHelper;
+};
+
+struct cmVisualStudio10TargetGenerator::OptionsHelper
+{
+  cmVS10GeneratorOptions& O;
+  OptionsHelper(cmVS10GeneratorOptions& o, Elem& e)
+    : O(o)
+  {
+    O.Parent = &e;
+  }
+  ~OptionsHelper() { O.Parent = nullptr; }
+
+  void OutputPreprocessorDefinitions(const std::string& lang)
+  {
+    O.OutputPreprocessorDefinitions(O.Parent->S, O.Parent->Indent + 1, lang);
+  }
+  void OutputAdditionalIncludeDirectories(const std::string& lang)
+  {
+    O.OutputAdditionalIncludeDirectories(O.Parent->S, O.Parent->Indent + 1,
+                                         lang);
+  }
+  void OutputFlagMap() { O.OutputFlagMap(O.Parent->S, O.Parent->Indent + 1); }
+  void PrependInheritedString(std::string const& key)
+  {
+    O.PrependInheritedString(key);
+  }
+};
+
 static std::string cmVS10EscapeComment(std::string comment)
 {
   // MSBuild takes the CDATA of a <Message></Message> element and just
@@ -74,9 +220,7 @@ static std::string computeProjectFileExtension(cmGeneratorTarget const* t,
 {
   std::string res;
   res = ".vcxproj";
-  std::string lang = t->GetLinkerLanguage(config);
-  if (cmGlobalVisualStudioGenerator::TargetIsCSharpOnly(t) ||
-      lang == "CSharp") {
+  if (t->HasLanguage("CSharp", config)) {
     res = ".csproj";
   }
   return res;
@@ -84,16 +228,16 @@ static std::string computeProjectFileExtension(cmGeneratorTarget const* t,
 
 cmVisualStudio10TargetGenerator::cmVisualStudio10TargetGenerator(
   cmGeneratorTarget* target, cmGlobalVisualStudio10Generator* gg)
+  : GeneratorTarget(target)
+  , Makefile(target->Target->GetMakefile())
+  , Platform(gg->GetPlatformName())
+  , Name(target->GetName())
+  , GUID(gg->GetGUID(this->Name))
+  , GlobalGenerator(gg)
+  , LocalGenerator(
+      (cmLocalVisualStudio10Generator*)target->GetLocalGenerator())
 {
-  this->GlobalGenerator = gg;
-  this->GeneratorTarget = target;
-  this->Makefile = target->Target->GetMakefile();
   this->Makefile->GetConfigurations(this->Configurations);
-  this->LocalGenerator =
-    (cmLocalVisualStudio7Generator*)this->GeneratorTarget->GetLocalGenerator();
-  this->Name = this->GeneratorTarget->GetName();
-  this->GUID = this->GlobalGenerator->GetGUID(this->Name);
-  this->Platform = gg->GetPlatformName();
   this->NsightTegra = gg->IsNsightTegra();
   for (int i = 0; i < 4; ++i) {
     this->NsightTegraVersion[i] = 0;
@@ -104,7 +248,6 @@ cmVisualStudio10TargetGenerator::cmVisualStudio10TargetGenerator(
   this->MSTools = !this->NsightTegra;
   this->Managed = false;
   this->TargetCompileAsWinRT = false;
-  this->BuildFileStream = 0;
   this->IsMissingFiles = false;
   this->DefaultArtifactDir =
     this->LocalGenerator->GetCurrentBinaryDirectory() + std::string("/") +
@@ -116,56 +259,40 @@ cmVisualStudio10TargetGenerator::cmVisualStudio10TargetGenerator(
 
 cmVisualStudio10TargetGenerator::~cmVisualStudio10TargetGenerator()
 {
-  if (!this->BuildFileStream) {
-    return;
-  }
-  if (this->BuildFileStream->Close()) {
-    this->GlobalGenerator->FileReplacedDuringGenerate(this->PathToProjectFile);
-  }
-  delete this->BuildFileStream;
 }
 
-void cmVisualStudio10TargetGenerator::WritePlatformConfigTag(
-  const char* tag, const std::string& config, int indentLevel,
-  const char* attribute, const char* end, std::ostream* stream)
-
+std::string cmVisualStudio10TargetGenerator::CalcCondition(
+  const std::string& config) const
 {
-  if (!stream) {
-    stream = this->BuildFileStream;
-  }
-  stream->fill(' ');
-  stream->width(indentLevel * 2);
-  (*stream) << ""; // applies indentation
-  (*stream) << "<" << tag << " Condition=\"";
-  (*stream) << "'$(Configuration)|$(Platform)'=='";
-  (*stream) << config << "|" << this->Platform;
-  (*stream) << "'";
+  std::ostringstream oss;
+  oss << "'$(Configuration)|$(Platform)'=='";
+  oss << config << "|" << this->Platform;
+  oss << "'";
   // handle special case for 32 bit C# targets
   if (this->ProjectType == csproj && this->Platform == "Win32") {
-    (*stream) << " Or ";
-    (*stream) << "'$(Configuration)|$(Platform)'=='";
-    (*stream) << config << "|x86";
-    (*stream) << "'";
-  }
-  (*stream) << "\"";
-  if (attribute) {
-    (*stream) << attribute;
-  }
-  // close the tag
-  (*stream) << ">";
-  if (end) {
-    (*stream) << end;
+    oss << " Or ";
+    oss << "'$(Configuration)|$(Platform)'=='";
+    oss << config << "|x86";
+    oss << "'";
   }
+  return oss.str();
 }
 
-void cmVisualStudio10TargetGenerator::WriteString(const char* line,
-                                                  int indentLevel)
+void cmVisualStudio10TargetGenerator::Elem::WritePlatformConfigTag(
+  const char* tag, const std::string& cond, const std::string& content)
 {
-  this->BuildFileStream->fill(' ');
-  this->BuildFileStream->width(indentLevel * 2);
+  Elem(*this, tag).Attribute("Condition", cond).Content(content);
+}
+
+std::ostream& cmVisualStudio10TargetGenerator::Elem::WriteString(
+  const char* line)
+{
+  this->S.fill(' ');
+  this->S.width(this->Indent * 2);
   // write an empty string to get the fill level indent to print
-  (*this->BuildFileStream) << "";
-  (*this->BuildFileStream) << line;
+  this->S << "";
+  this->S << line;
+  return this->S;
 }
 
 #define VS10_CXX_DEFAULT_PROPS "$(VCTargetsPath)\\Microsoft.Cpp.Default.props"
@@ -189,20 +316,30 @@ void cmVisualStudio10TargetGenerator::Generate()
       this->GeneratorTarget->GetProperty("EXTERNAL_MSPROJECT")) {
     return;
   }
-  this->ProjectFileExtension = computeProjectFileExtension(
+  const std::string ProjectFileExtension = computeProjectFileExtension(
     this->GeneratorTarget, *this->Configurations.begin());
-  if (this->ProjectFileExtension == ".vcxproj") {
+  if (ProjectFileExtension == ".vcxproj") {
     this->ProjectType = vcxproj;
     this->Managed = false;
-  } else if (this->ProjectFileExtension == ".csproj") {
+  } else if (ProjectFileExtension == ".csproj") {
+    if (this->GeneratorTarget->GetType() == cmStateEnums::STATIC_LIBRARY) {
+      std::string message = "The C# target \"" +
+        this->GeneratorTarget->GetName() +
+        "\" is of type STATIC_LIBRARY. This is discouraged (and may be "
+        "disabled in future). Make it a SHARED library instead.";
+      this->Makefile->IssueMessage(cmake::MessageType::DEPRECATION_WARNING,
+                                   message);
+    }
     this->ProjectType = csproj;
     this->Managed = true;
   }
   // 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_EXT", this->ProjectFileExtension.c_str());
+  this->GeneratorTarget->Target->SetProperty("GENERATOR_FILE_NAME_EXT",
+                                             ProjectFileExtension.c_str());
+  this->DotNetHintReferences.clear();
+  this->AdditionalUsingDirectories.clear();
   if (this->GeneratorTarget->GetType() <= cmStateEnums::OBJECT_LIBRARY) {
     if (!this->ComputeClOptions()) {
       return;
@@ -232,365 +369,348 @@ void cmVisualStudio10TargetGenerator::Generate()
   std::string path = this->LocalGenerator->GetCurrentBinaryDirectory();
   path += "/";
   path += this->Name;
-  path += this->ProjectFileExtension;
-  this->BuildFileStream = new cmGeneratedFileStream(path.c_str());
-  this->PathToProjectFile = path;
-  this->BuildFileStream->SetCopyIfDifferent(true);
+  path += ProjectFileExtension;
+  cmGeneratedFileStream BuildFileStream(path.c_str());
+  const std::string PathToProjectFile = path;
+  BuildFileStream.SetCopyIfDifferent(true);
 
   // Write the encoding header into the file
   char magic[] = { char(0xEF), char(0xBB), char(0xBF) };
-  this->BuildFileStream->write(magic, 3);
-
-  // get the tools version to use
-  const std::string toolsVer(this->GlobalGenerator->GetToolsVersion());
-  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(
-    "xmlns=\"http://schemas.microsoft.com/developer/msbuild/2003\">\n");
-  this->WriteString(project_defaults.c_str(), 0);
-
-  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) {
-      this->WriteString("<NsightTegraProjectRevisionNumber>", 2);
-      if (nsightTegraMajorVersion > 3 ||
-          (nsightTegraMajorVersion == 3 && nsightTegraMinorVersion >= 1)) {
-        (*this->BuildFileStream) << "11";
+  BuildFileStream.write(magic, 3);
+  BuildFileStream << "<?xml version=\"1.0\" encoding=\""
+                  << this->GlobalGenerator->Encoding() << "\"?>"
+                  << "\n";
+  {
+    Elem e0(BuildFileStream);
+    e0.StartElement("Project");
+    e0.Attribute("DefaultTargets", "Build");
+    e0.Attribute("ToolsVersion", this->GlobalGenerator->GetToolsVersion());
+    e0.Attribute("xmlns",
+                 "http://schemas.microsoft.com/developer/msbuild/2003");
+
+    if (this->NsightTegra) {
+      Elem e1(e0, "PropertyGroup");
+      e1.Attribute("Label", "NsightTegraProject");
+      const unsigned int nsightTegraMajorVersion = this->NsightTegraVersion[0];
+      const unsigned int nsightTegraMinorVersion = this->NsightTegraVersion[1];
+      if (nsightTegraMajorVersion >= 2) {
+        if (nsightTegraMajorVersion > 3 ||
+            (nsightTegraMajorVersion == 3 && nsightTegraMinorVersion >= 1)) {
+          e1.Element("NsightTegraProjectRevisionNumber", "11");
+        } else {
+          // Nsight Tegra 2.0 uses project revision 9.
+          e1.Element("NsightTegraProjectRevisionNumber", "9");
+        }
+        // Tell newer versions to upgrade silently when loading.
+        e1.Element("NsightTegraUpgradeOnceWithoutPrompt", "true");
       } else {
-        // Nsight Tegra 2.0 uses project revision 9.
-        (*this->BuildFileStream) << "9";
+        // Require Nsight Tegra 1.6 for JCompile support.
+        e1.Element("NsightTegraProjectRevisionNumber", "7");
       }
-      (*this->BuildFileStream) << "</NsightTegraProjectRevisionNumber>\n";
-      // Tell newer versions to upgrade silently when loading.
-      this->WriteString("<NsightTegraUpgradeOnceWithoutPrompt>"
-                        "true"
-                        "</NsightTegraUpgradeOnceWithoutPrompt>\n",
-                        2);
-    } else {
-      // Require Nsight Tegra 1.6 for JCompile support.
-      this->WriteString("<NsightTegraProjectRevisionNumber>"
-                        "7"
-                        "</NsightTegraProjectRevisionNumber>\n",
-                        2);
     }
-    this->WriteString("</PropertyGroup>\n", 1);
-  }
 
-  if (const char* hostArch =
-        this->GlobalGenerator->GetPlatformToolsetHostArchitecture()) {
-    this->WriteString("<PropertyGroup>\n", 1);
-    this->WriteString("<PreferredToolArchitecture>", 2);
-    (*this->BuildFileStream) << cmVS10EscapeXML(hostArch)
-                             << "</PreferredToolArchitecture>\n";
-    this->WriteString("</PropertyGroup>\n", 1);
-  }
+    if (const char* hostArch =
+          this->GlobalGenerator->GetPlatformToolsetHostArchitecture()) {
+      Elem e1(e0, "PropertyGroup");
+      e1.Element("PreferredToolArchitecture", hostArch);
+    }
 
-  if (this->ProjectType != csproj) {
-    this->WriteProjectConfigurations();
-  }
-  this->WriteString("<PropertyGroup Label=\"Globals\">\n", 1);
-  this->WriteString("<ProjectGuid>", 2);
-  (*this->BuildFileStream) << "{" << this->GUID << "}</ProjectGuid>\n";
+    if (this->ProjectType != csproj) {
+      this->WriteProjectConfigurations(e0);
+    }
 
-  if (this->MSTools &&
-      this->GeneratorTarget->GetType() <= cmStateEnums::GLOBAL_TARGET) {
-    this->WriteApplicationTypeSettings();
-    this->VerifyNecessaryFiles();
-  }
+    {
+      Elem e1(e0, "PropertyGroup");
+      e1.Attribute("Label", "Globals");
+      e1.Element("ProjectGuid", "{" + this->GUID + "}");
+
+      if (this->MSTools &&
+          this->GeneratorTarget->GetType() <= cmStateEnums::GLOBAL_TARGET) {
+        this->WriteApplicationTypeSettings(e1);
+        this->VerifyNecessaryFiles();
+      }
 
-  const char* vsProjectTypes =
-    this->GeneratorTarget->GetProperty("VS_GLOBAL_PROJECT_TYPES");
-  if (vsProjectTypes) {
-    std::string tagName = "ProjectTypes";
-    if (this->ProjectType == csproj) {
-      tagName = "ProjectTypeGuids";
-    }
-    this->WriteString("", 2);
-    (*this->BuildFileStream) << "<" << tagName << ">"
-                             << cmVS10EscapeXML(vsProjectTypes) << "</"
-                             << tagName << ">\n";
-  }
+      const char* vsProjectTypes =
+        this->GeneratorTarget->GetProperty("VS_GLOBAL_PROJECT_TYPES");
+      if (vsProjectTypes) {
+        const char* tagName = "ProjectTypes";
+        if (this->ProjectType == csproj) {
+          tagName = "ProjectTypeGuids";
+        }
+        e1.Element(tagName, vsProjectTypes);
+      }
 
-  const char* vsProjectName =
-    this->GeneratorTarget->GetProperty("VS_SCC_PROJECTNAME");
-  const char* vsLocalPath =
-    this->GeneratorTarget->GetProperty("VS_SCC_LOCALPATH");
-  const char* vsProvider =
-    this->GeneratorTarget->GetProperty("VS_SCC_PROVIDER");
+      const char* vsProjectName =
+        this->GeneratorTarget->GetProperty("VS_SCC_PROJECTNAME");
+      const char* vsLocalPath =
+        this->GeneratorTarget->GetProperty("VS_SCC_LOCALPATH");
+      const char* vsProvider =
+        this->GeneratorTarget->GetProperty("VS_SCC_PROVIDER");
+
+      if (vsProjectName && vsLocalPath && vsProvider) {
+        e1.Element("SccProjectName", vsProjectName);
+        e1.Element("SccLocalPath", vsLocalPath);
+        e1.Element("SccProvider", vsProvider);
+
+        const char* vsAuxPath =
+          this->GeneratorTarget->GetProperty("VS_SCC_AUXPATH");
+        if (vsAuxPath) {
+          e1.Element("SccAuxPath", vsAuxPath);
+        }
+      }
 
-  if (vsProjectName && vsLocalPath && vsProvider) {
-    this->WriteString("<SccProjectName>", 2);
-    (*this->BuildFileStream) << cmVS10EscapeXML(vsProjectName)
-                             << "</SccProjectName>\n";
-    this->WriteString("<SccLocalPath>", 2);
-    (*this->BuildFileStream) << cmVS10EscapeXML(vsLocalPath)
-                             << "</SccLocalPath>\n";
-    this->WriteString("<SccProvider>", 2);
-    (*this->BuildFileStream) << cmVS10EscapeXML(vsProvider)
-                             << "</SccProvider>\n";
+      if (this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_COMPONENT")) {
+        e1.Element("WinMDAssembly", "true");
+      }
 
-    const char* vsAuxPath =
-      this->GeneratorTarget->GetProperty("VS_SCC_AUXPATH");
-    if (vsAuxPath) {
-      this->WriteString("<SccAuxPath>", 2);
-      (*this->BuildFileStream) << cmVS10EscapeXML(vsAuxPath)
-                               << "</SccAuxPath>\n";
-    }
-  }
+      const char* vsGlobalKeyword =
+        this->GeneratorTarget->GetProperty("VS_GLOBAL_KEYWORD");
+      if (!vsGlobalKeyword) {
+        e1.Element("Keyword", "Win32Proj");
+      } else {
+        e1.Element("Keyword", vsGlobalKeyword);
+      }
 
-  if (this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_COMPONENT")) {
-    this->WriteString("<WinMDAssembly>true</WinMDAssembly>\n", 2);
-  }
+      const char* vsGlobalRootNamespace =
+        this->GeneratorTarget->GetProperty("VS_GLOBAL_ROOTNAMESPACE");
+      if (vsGlobalRootNamespace) {
+        e1.Element("RootNamespace", vsGlobalRootNamespace);
+      }
 
-  const char* vsGlobalKeyword =
-    this->GeneratorTarget->GetProperty("VS_GLOBAL_KEYWORD");
-  if (!vsGlobalKeyword) {
-    this->WriteString("<Keyword>Win32Proj</Keyword>\n", 2);
-  } else {
-    this->WriteString("<Keyword>", 2);
-    (*this->BuildFileStream) << cmVS10EscapeXML(vsGlobalKeyword)
-                             << "</Keyword>\n";
-  }
-
-  const char* vsGlobalRootNamespace =
-    this->GeneratorTarget->GetProperty("VS_GLOBAL_ROOTNAMESPACE");
-  if (vsGlobalRootNamespace) {
-    this->WriteString("<RootNamespace>", 2);
-    (*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) {
-    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")) {
-    this->WriteString("<TargetFrameworkVersion>", 2);
-    (*this->BuildFileStream) << cmVS10EscapeXML(targetFrameworkVersion)
-                             << "</TargetFrameworkVersion>\n";
-  }
-
-  // Disable the project upgrade prompt that is displayed the first time a
-  // project using an older toolset version is opened in a newer version of
-  // the IDE (respected by VS 2013 and above).
-  if (this->GlobalGenerator->GetVersion() >=
-      cmGlobalVisualStudioGenerator::VS12) {
-    this->WriteString("<VCProjectUpgraderObjectName>NoUpgrade"
-                      "</VCProjectUpgraderObjectName>\n",
-                      2);
-  }
-
-  std::vector<std::string> keys = this->GeneratorTarget->GetPropertyKeys();
-  for (std::string const& keyIt : keys) {
-    static const char* prefix = "VS_GLOBAL_";
-    if (keyIt.find(prefix) != 0)
-      continue;
-    std::string globalKey = keyIt.substr(strlen(prefix));
-    // Skip invalid or separately-handled properties.
-    if (globalKey.empty() || globalKey == "PROJECT_TYPES" ||
-        globalKey == "ROOTNAMESPACE" || globalKey == "KEYWORD") {
-      continue;
+      e1.Element("Platform", this->Platform);
+      const char* projLabel =
+        this->GeneratorTarget->GetProperty("PROJECT_LABEL");
+      if (!projLabel) {
+        projLabel = this->Name.c_str();
+      }
+      e1.Element("ProjectName", projLabel);
+      {
+        // TODO: add deprecation warning for VS_* property?
+        const char* targetFrameworkVersion =
+          this->GeneratorTarget->GetProperty(
+            "VS_DOTNET_TARGET_FRAMEWORK_VERSION");
+        if (!targetFrameworkVersion) {
+          targetFrameworkVersion = this->GeneratorTarget->GetProperty(
+            "DOTNET_TARGET_FRAMEWORK_VERSION");
+        }
+        if (targetFrameworkVersion) {
+          e1.Element("TargetFrameworkVersion", targetFrameworkVersion);
+        }
+      }
+
+      // Disable the project upgrade prompt that is displayed the first time a
+      // project using an older toolset version is opened in a newer version of
+      // the IDE (respected by VS 2013 and above).
+      if (this->GlobalGenerator->GetVersion() >=
+          cmGlobalVisualStudioGenerator::VS12) {
+        e1.Element("VCProjectUpgraderObjectName", "NoUpgrade");
+      }
+
+      std::vector<std::string> keys = this->GeneratorTarget->GetPropertyKeys();
+      for (std::string const& keyIt : keys) {
+        static const char* prefix = "VS_GLOBAL_";
+        if (keyIt.find(prefix) != 0)
+          continue;
+        std::string globalKey = keyIt.substr(strlen(prefix));
+        // Skip invalid or separately-handled properties.
+        if (globalKey.empty() || globalKey == "PROJECT_TYPES" ||
+            globalKey == "ROOTNAMESPACE" || globalKey == "KEYWORD") {
+          continue;
+        }
+        const char* value = this->GeneratorTarget->GetProperty(keyIt);
+        if (!value)
+          continue;
+        e1.Element(globalKey.c_str(), value);
+      }
+
+      if (this->Managed) {
+        std::string outputType;
+        switch (this->GeneratorTarget->GetType()) {
+          case cmStateEnums::OBJECT_LIBRARY:
+          case cmStateEnums::STATIC_LIBRARY:
+          case cmStateEnums::SHARED_LIBRARY:
+            outputType = "Library";
+            break;
+          case cmStateEnums::MODULE_LIBRARY:
+            outputType = "Module";
+            break;
+          case cmStateEnums::EXECUTABLE:
+            if (this->GeneratorTarget->Target->GetPropertyAsBool(
+                  "WIN32_EXECUTABLE")) {
+              outputType = "WinExe";
+            } else {
+              outputType = "Exe";
+            }
+            break;
+          case cmStateEnums::UTILITY:
+          case cmStateEnums::GLOBAL_TARGET:
+            outputType = "Utility";
+            break;
+          case cmStateEnums::UNKNOWN_LIBRARY:
+          case cmStateEnums::INTERFACE_LIBRARY:
+            break;
+        }
+        e1.Element("OutputType", outputType);
+        e1.Element("AppDesignerFolder", "Properties");
+      }
     }
-    const char* value = this->GeneratorTarget->GetProperty(keyIt);
-    if (!value)
-      continue;
-    this->WriteString("<", 2);
-    (*this->BuildFileStream) << globalKey << ">" << cmVS10EscapeXML(value)
-                             << "</" << globalKey << ">\n";
-  }
 
-  if (this->Managed) {
-    std::string outputType = "<OutputType>";
-    switch (this->GeneratorTarget->GetType()) {
-      case cmStateEnums::OBJECT_LIBRARY:
-      case cmStateEnums::STATIC_LIBRARY:
-      case cmStateEnums::SHARED_LIBRARY:
-        outputType += "Library";
-        break;
-      case cmStateEnums::MODULE_LIBRARY:
-        outputType += "Module";
-        break;
-      case cmStateEnums::EXECUTABLE:
-        if (this->GeneratorTarget->Target->GetPropertyAsBool(
-              "WIN32_EXECUTABLE")) {
-          outputType += "WinExe";
-        } else {
-          outputType += "Exe";
+    switch (this->ProjectType) {
+      case vcxproj:
+        if (this->GlobalGenerator->GetPlatformToolsetVersion()) {
+          Elem(e0, "Import")
+            .Attribute("Project",
+                       this->GlobalGenerator->GetAuxiliaryToolset());
         }
+        Elem(e0, "Import").Attribute("Project", VS10_CXX_DEFAULT_PROPS);
         break;
-      case cmStateEnums::UTILITY:
-      case cmStateEnums::GLOBAL_TARGET:
-        outputType += "Utility";
-        break;
-      case cmStateEnums::UNKNOWN_LIBRARY:
-      case cmStateEnums::INTERFACE_LIBRARY:
+      case csproj:
+        Elem(e0, "Import")
+          .Attribute("Project", VS10_CSharp_DEFAULT_PROPS)
+          .Attribute("Condition", "Exists('" VS10_CSharp_DEFAULT_PROPS "')");
         break;
     }
-    outputType += "</OutputType>\n";
-    this->WriteString(outputType.c_str(), 2);
-    this->WriteString("<AppDesignerFolder>Properties</AppDesignerFolder>\n",
-                      2);
-  }
 
-  this->WriteString("</PropertyGroup>\n", 1);
+    this->WriteProjectConfigurationValues(e0);
 
-  switch (this->ProjectType) {
-    case vcxproj:
-      this->WriteString("<Import Project=\"" VS10_CXX_DEFAULT_PROPS "\" />\n",
-                        1);
-      break;
-    case csproj:
-      this->WriteString("<Import Project=\"" VS10_CSharp_DEFAULT_PROPS "\" "
-                        "Condition=\"Exists('" VS10_CSharp_DEFAULT_PROPS "')\""
-                        "/>\n",
-                        1);
-      break;
-  }
+    if (this->ProjectType == vcxproj) {
+      Elem(e0, "Import").Attribute("Project", VS10_CXX_PROPS);
+    }
+    {
+      Elem e1(e0, "ImportGroup");
+      e1.Attribute("Label", "ExtensionSettings");
+      e1.SetHasElements();
+
+      if (this->GlobalGenerator->IsCudaEnabled()) {
+        Elem(e1, "Import")
+          .Attribute("Project",
+                     "$(VCTargetsPath)\\BuildCustomizations\\CUDA " +
+                       this->GlobalGenerator->GetPlatformToolsetCudaString() +
+                       ".props");
+      }
+      if (this->GlobalGenerator->IsMasmEnabled()) {
+        Elem(e1, "Import")
+          .Attribute("Project",
+                     "$(VCTargetsPath)\\BuildCustomizations\\masm.props");
+      }
+      if (this->GlobalGenerator->IsNasmEnabled()) {
+        // Always search in the standard modules location.
+        std::string propsTemplate =
+          GetCMakeFilePath("Templates/MSBuild/nasm.props.in");
+
+        std::string propsLocal;
+        propsLocal += this->DefaultArtifactDir;
+        propsLocal += "\\nasm.props";
+        ConvertToWindowsSlash(propsLocal);
+        this->Makefile->ConfigureFile(propsTemplate.c_str(),
+                                      propsLocal.c_str(), false, true, true);
+        Elem(e1, "Import").Attribute("Project", propsLocal);
+      }
+    }
+    {
+      Elem e1(e0, "ImportGroup");
+      e1.Attribute("Label", "PropertySheets");
+      std::string props;
+      switch (this->ProjectType) {
+        case vcxproj:
+          props = VS10_CXX_USER_PROPS;
+          break;
+        case csproj:
+          props = VS10_CSharp_USER_PROPS;
+          break;
+      }
+      if (const char* p =
+            this->GeneratorTarget->GetProperty("VS_USER_PROPS")) {
+        props = p;
+      }
+      if (!props.empty()) {
+        ConvertToWindowsSlash(props);
+        Elem(e1, "Import")
+          .Attribute("Project", props)
+          .Attribute("Condition", "exists('" + props + "')")
+          .Attribute("Label", "LocalAppDataPlatform");
+      }
 
-  this->WriteProjectConfigurationValues();
-
-  if (this->ProjectType == vcxproj) {
-    this->WriteString("<Import Project=\"" VS10_CXX_PROPS "\" />\n", 1);
-  }
-  this->WriteString("<ImportGroup Label=\"ExtensionSettings\">\n", 1);
-  if (this->GlobalGenerator->IsCudaEnabled()) {
-    this->WriteString("<Import Project=\"$(VCTargetsPath)\\"
-                      "BuildCustomizations\\CUDA ",
-                      2);
-    (*this->BuildFileStream)
-      << cmVS10EscapeXML(this->GlobalGenerator->GetPlatformToolsetCudaString())
-      << ".props\" />\n";
-  }
-  if (this->GlobalGenerator->IsMasmEnabled()) {
-    this->WriteString("<Import Project=\"$(VCTargetsPath)\\"
-                      "BuildCustomizations\\masm.props\" />\n",
-                      2);
-  }
-  if (this->GlobalGenerator->IsNasmEnabled()) {
-    // Always search in the standard modules location.
-    std::string propsTemplate =
-      GetCMakeFilePath("Templates/MSBuild/nasm.props.in");
-
-    std::string propsLocal;
-    propsLocal += this->DefaultArtifactDir;
-    propsLocal += "\\nasm.props";
-    ConvertToWindowsSlash(propsLocal);
-    this->Makefile->ConfigureFile(propsTemplate.c_str(), propsLocal.c_str(),
-                                  false, true, true);
-    std::string import = std::string("<Import Project=\"") +
-      cmVS10EscapeXML(propsLocal) + "\" />\n";
-    this->WriteString(import.c_str(), 2);
-  }
-  this->WriteString("</ImportGroup>\n", 1);
-  this->WriteString("<ImportGroup Label=\"PropertySheets\">\n", 1);
-  {
-    std::string props;
+      this->WritePlatformExtensions(e1);
+    }
+    Elem(e0, "PropertyGroup").Attribute("Label", "UserMacros");
+    this->WriteWinRTPackageCertificateKeyFile(e0);
+    this->WritePathAndIncrementalLinkOptions(e0);
+    this->WriteItemDefinitionGroups(e0);
+    this->WriteCustomCommands(e0);
+    this->WriteAllSources(e0);
+    this->WriteDotNetReferences(e0);
+    this->WriteEmbeddedResourceGroup(e0);
+    this->WriteXamlFilesGroup(e0);
+    this->WriteWinRTReferences(e0);
+    this->WriteProjectReferences(e0);
+    this->WriteSDKReferences(e0);
     switch (this->ProjectType) {
       case vcxproj:
-        props = VS10_CXX_USER_PROPS;
+        Elem(e0, "Import").Attribute("Project", VS10_CXX_TARGETS);
         break;
       case csproj:
-        props = VS10_CSharp_USER_PROPS;
+        Elem(e0, "Import").Attribute("Project", VS10_CSharp_TARGETS);
         break;
     }
-    if (const char* p = this->GeneratorTarget->GetProperty("VS_USER_PROPS")) {
-      props = p;
-    }
-    if (!props.empty()) {
-      ConvertToWindowsSlash(props);
-      this->WriteString("", 2);
-      (*this->BuildFileStream)
-        << "<Import Project=\"" << cmVS10EscapeXML(props) << "\""
-        << " Condition=\"exists('" << cmVS10EscapeXML(props) << "')\""
-        << " Label=\"LocalAppDataPlatform\" />\n";
-    }
-  }
-  this->WritePlatformExtensions();
-  this->WriteString("</ImportGroup>\n", 1);
-  this->WriteString("<PropertyGroup Label=\"UserMacros\" />\n", 1);
-  this->WriteWinRTPackageCertificateKeyFile();
-  this->WritePathAndIncrementalLinkOptions();
-  this->WriteItemDefinitionGroups();
-  this->WriteCustomCommands();
-  this->WriteAllSources();
-  this->WriteDotNetReferences();
-  this->WriteEmbeddedResourceGroup();
-  this->WriteXamlFilesGroup();
-  this->WriteWinRTReferences();
-  this->WriteProjectReferences();
-  this->WriteSDKReferences();
-  switch (this->ProjectType) {
-    case vcxproj:
-      this->WriteString("<Import Project=\"" VS10_CXX_TARGETS "\" />\n", 1);
-      break;
-    case csproj:
-      this->WriteString("<Import Project=\"" VS10_CSharp_TARGETS "\" />\n", 1);
-      break;
+
+    this->WriteTargetSpecificReferences(e0);
+    {
+      Elem e1(e0, "ImportGroup");
+      e1.Attribute("Label", "ExtensionTargets");
+      e1.SetHasElements();
+      this->WriteTargetsFileReferences(e1);
+      if (this->GlobalGenerator->IsCudaEnabled()) {
+        Elem(e1, "Import")
+          .Attribute("Project",
+                     "$(VCTargetsPath)\\BuildCustomizations\\CUDA " +
+                       this->GlobalGenerator->GetPlatformToolsetCudaString() +
+                       ".targets");
+      }
+      if (this->GlobalGenerator->IsMasmEnabled()) {
+        Elem(e1, "Import")
+          .Attribute("Project",
+                     "$(VCTargetsPath)\\BuildCustomizations\\masm.targets");
+      }
+      if (this->GlobalGenerator->IsNasmEnabled()) {
+        std::string nasmTargets =
+          GetCMakeFilePath("Templates/MSBuild/nasm.targets");
+        Elem(e1, "Import").Attribute("Project", nasmTargets);
+      }
+    }
+    if (this->ProjectType == csproj) {
+      for (std::string const& c : this->Configurations) {
+        Elem e1(e0, "PropertyGroup");
+        e1.Attribute("Condition", "'$(Configuration)' == '" + c + "'");
+        e1.SetHasElements();
+        this->WriteEvents(e1, c);
+      }
+      // make sure custom commands are executed before build (if necessary)
+      {
+        Elem e1(e0, "PropertyGroup");
+        std::ostringstream oss;
+        oss << "\n";
+        for (std::string const& i : this->CSharpCustomCommandNames) {
+          oss << "      " << i << ";\n";
+        }
+        oss << "      "
+            << "$(BuildDependsOn)\n";
+        e1.Element("BuildDependsOn", oss.str());
+      }
+    }
+  }
+
+  if (BuildFileStream.Close()) {
+    this->GlobalGenerator->FileReplacedDuringGenerate(PathToProjectFile);
   }
 
-  this->WriteTargetSpecificReferences();
-  this->WriteString("<ImportGroup Label=\"ExtensionTargets\">\n", 1);
-  this->WriteTargetsFileReferences();
-  if (this->GlobalGenerator->IsCudaEnabled()) {
-    this->WriteString("<Import Project=\"$(VCTargetsPath)\\"
-                      "BuildCustomizations\\CUDA ",
-                      2);
-    (*this->BuildFileStream)
-      << cmVS10EscapeXML(this->GlobalGenerator->GetPlatformToolsetCudaString())
-      << ".targets\" />\n";
-  }
-  if (this->GlobalGenerator->IsMasmEnabled()) {
-    this->WriteString("<Import Project=\"$(VCTargetsPath)\\"
-                      "BuildCustomizations\\masm.targets\" />\n",
-                      2);
-  }
-  if (this->GlobalGenerator->IsNasmEnabled()) {
-    std::string nasmTargets =
-      GetCMakeFilePath("Templates/MSBuild/nasm.targets");
-    std::string import = "<Import Project=\"";
-    import += cmVS10EscapeXML(nasmTargets) + "\" />\n";
-    this->WriteString(import.c_str(), 2);
-  }
-  this->WriteString("</ImportGroup>\n", 1);
-  if (this->ProjectType == csproj) {
-    for (std::string const& i : this->Configurations) {
-      this->WriteString("<PropertyGroup Condition=\"'$(Configuration)' == '",
-                        1);
-      (*this->BuildFileStream) << i << "'\">\n";
-      this->WriteEvents(i);
-      this->WriteString("</PropertyGroup>\n", 1);
-    }
-    // make sure custom commands are executed before build (if necessary)
-    this->WriteString("<PropertyGroup>\n", 1);
-    this->WriteString("<BuildDependsOn>\n", 2);
-    for (std::string const& i : this->CSharpCustomCommandNames) {
-      this->WriteString(i.c_str(), 3);
-      (*this->BuildFileStream) << ";\n";
-    }
-    this->WriteString("$(BuildDependsOn)\n", 3);
-    this->WriteString("</BuildDependsOn>\n", 2);
-    this->WriteString("</PropertyGroup>\n", 1);
-  }
-  this->WriteString("</Project>", 0);
   // The groups are stored in a separate file for VS 10
   this->WriteGroups();
 }
 
-void cmVisualStudio10TargetGenerator::WriteDotNetReferences()
+void cmVisualStudio10TargetGenerator::WriteDotNetReferences(Elem& e0)
 {
   std::vector<std::string> references;
-  typedef std::pair<std::string, std::string> HintReference;
-  std::vector<HintReference> hintReferences;
   if (const char* vsDotNetReferences =
         this->GeneratorTarget->GetProperty("VS_DOTNET_REFERENCES")) {
     cmSystemTools::ExpandListArgument(vsDotNetReferences, references);
@@ -602,17 +722,17 @@ void cmVisualStudio10TargetGenerator::WriteDotNetReferences()
       if (!name.empty()) {
         std::string path = i.second.GetValue();
         if (!cmsys::SystemTools::FileIsFullPath(path)) {
-          path = std::string(this->GeneratorTarget->Target->GetMakefile()
-                               ->GetCurrentSourceDirectory()) +
+          path = std::string(this->Makefile->GetCurrentSourceDirectory()) +
             "/" + path;
         }
         ConvertToWindowsSlash(path);
-        hintReferences.push_back(HintReference(name, path));
+        this->DotNetHintReferences[""].push_back(
+          DotNetHintReference(name, path));
       }
     }
   }
-  if (!references.empty() || !hintReferences.empty()) {
-    this->WriteString("<ItemGroup>\n", 1);
+  if (!references.empty() || !this->DotNetHintReferences.empty()) {
+    Elem e1(e0, "ItemGroup");
     for (std::string const& ri : references) {
       // if the entry from VS_DOTNET_REFERENCES is an existing file, generate
       // a new hint-reference and name it from the filename
@@ -620,29 +740,36 @@ void cmVisualStudio10TargetGenerator::WriteDotNetReferences()
         std::string name = cmsys::SystemTools::GetFilenameWithoutExtension(ri);
         std::string path = ri;
         ConvertToWindowsSlash(path);
-        hintReferences.push_back(HintReference(name, path));
+        this->DotNetHintReferences[""].push_back(
+          DotNetHintReference(name, path));
       } else {
-        this->WriteDotNetReference(ri, "");
+        this->WriteDotNetReference(e1, ri, "", "");
       }
     }
-    for (const auto& i : hintReferences) {
-      this->WriteDotNetReference(i.first, i.second);
+    for (const auto& h : this->DotNetHintReferences) {
+      // DotNetHintReferences is also populated from AddLibraries().
+      // The configuration specific hint references are added there.
+      for (const auto& i : h.second) {
+        this->WriteDotNetReference(e1, i.first, i.second, h.first);
+      }
     }
-    this->WriteString("</ItemGroup>\n", 1);
   }
 }
 
 void cmVisualStudio10TargetGenerator::WriteDotNetReference(
-  std::string const& ref, std::string const& hint)
+  Elem& e1, std::string const& ref, std::string const& hint,
+  std::string const& config)
 {
-  this->WriteString("<Reference Include=\"", 2);
-  (*this->BuildFileStream) << cmVS10EscapeXML(ref) << "\">\n";
-  this->WriteString("<CopyLocalSatelliteAssemblies>true"
-                    "</CopyLocalSatelliteAssemblies>\n",
-                    3);
-  this->WriteString("<ReferenceOutputAssembly>true"
-                    "</ReferenceOutputAssembly>\n",
-                    3);
+  Elem e2(e1, "Reference");
+  // If 'config' is not empty, the reference is only added for the given
+  // configuration. This is used when referencing imported managed assemblies.
+  // See also cmVisualStudio10TargetGenerator::AddLibraries().
+  if (!config.empty()) {
+    e2.Attribute("Condition", this->CalcCondition(config));
+  }
+  e2.Attribute("Include", ref);
+  e2.Element("CopyLocalSatelliteAssemblies", "true");
+  e2.Element("ReferenceOutputAssembly", "true");
   if (!hint.empty()) {
     const char* privateReference = "True";
     if (const char* value = this->GeneratorTarget->GetProperty(
@@ -651,17 +778,14 @@ void cmVisualStudio10TargetGenerator::WriteDotNetReference(
         privateReference = "False";
       }
     }
-    this->WriteString("<Private>", 3);
-    (*this->BuildFileStream) << privateReference << "</Private>\n";
-    this->WriteString("<HintPath>", 3);
-    (*this->BuildFileStream) << hint << "</HintPath>\n";
+    e2.Element("Private", privateReference);
+    e2.Element("HintPath", hint);
   }
-  this->WriteDotNetReferenceCustomTags(ref);
-  this->WriteString("</Reference>\n", 2);
+  this->WriteDotNetReferenceCustomTags(e2, ref);
 }
 
 void cmVisualStudio10TargetGenerator::WriteDotNetReferenceCustomTags(
-  std::string const& ref)
+  Elem& e2, std::string const& ref)
 {
 
   static const std::string refpropPrefix = "VS_DOTNET_REFERENCEPROP_";
@@ -680,23 +804,20 @@ void cmVisualStudio10TargetGenerator::WriteDotNetReferenceCustomTags(
     }
   }
   for (auto const& tag : tags) {
-    this->WriteString("<", 3);
-    (*this->BuildFileStream) << tag.first << ">" << cmVS10EscapeXML(tag.second)
-                             << "</" << tag.first << ">\n";
+    e2.Element(tag.first.c_str(), tag.second);
   }
 }
 
-void cmVisualStudio10TargetGenerator::WriteEmbeddedResourceGroup()
+void cmVisualStudio10TargetGenerator::WriteEmbeddedResourceGroup(Elem& e0)
 {
   std::vector<cmSourceFile const*> resxObjs;
   this->GeneratorTarget->GetResxSources(resxObjs, "");
   if (!resxObjs.empty()) {
-    this->WriteString("<ItemGroup>\n", 1);
+    Elem e1(e0, "ItemGroup");
     std::string srcDir = this->Makefile->GetCurrentSourceDirectory();
     ConvertToWindowsSlash(srcDir);
     for (cmSourceFile const* oi : resxObjs) {
       std::string obj = oi->GetFullPath();
-      this->WriteString("<EmbeddedResource Include=\"", 2);
       ConvertToWindowsSlash(obj);
       bool useRelativePath = false;
       if (this->ProjectType == csproj && this->InSourceBuild) {
@@ -710,23 +831,22 @@ void cmVisualStudio10TargetGenerator::WriteEmbeddedResourceGroup()
           useRelativePath = true;
         }
       }
-      (*this->BuildFileStream) << obj << "\">\n";
+      Elem e2(e1, "EmbeddedResource");
+      e2.Attribute("Include", obj);
 
       if (this->ProjectType != csproj) {
-        this->WriteString("<DependentUpon>", 3);
         std::string hFileName = obj.substr(0, obj.find_last_of(".")) + ".h";
-        (*this->BuildFileStream) << hFileName << "</DependentUpon>\n";
+        e2.Element("DependentUpon", hFileName);
 
-        for (std::string const& i : this->Configurations) {
-          this->WritePlatformConfigTag("LogicalName", i, 3);
+        for (std::string const& c : this->Configurations) {
+          std::string s;
           if (this->GeneratorTarget->GetProperty("VS_GLOBAL_ROOTNAMESPACE") ||
               // Handle variant of VS_GLOBAL_<variable> for RootNamespace.
               this->GeneratorTarget->GetProperty("VS_GLOBAL_RootNamespace")) {
-            (*this->BuildFileStream) << "$(RootNamespace).";
+            s = "$(RootNamespace).";
           }
-          (*this->BuildFileStream) << "%(Filename)";
-          (*this->BuildFileStream) << ".resources";
-          (*this->BuildFileStream) << "</LogicalName>\n";
+          s += "%(Filename).resources";
+          e2.WritePlatformConfigTag("LogicalName", this->CalcCondition(c), s);
         }
       } else {
         std::string binDir = this->Makefile->GetCurrentBinaryDirectory();
@@ -743,8 +863,7 @@ void cmVisualStudio10TargetGenerator::WriteEmbeddedResourceGroup()
             link = cmsys::SystemTools::GetFilenameName(obj);
           }
           if (!link.empty()) {
-            this->WriteString("<Link>", 3);
-            (*this->BuildFileStream) << link << "</Link>\n";
+            e2.Element("Link", link);
           }
         }
         // Determine if this is a generated resource from a .Designer.cs file
@@ -758,9 +877,7 @@ void cmVisualStudio10TargetGenerator::WriteEmbeddedResourceGroup()
             generator = g;
           }
           if (!generator.empty()) {
-            this->WriteString("<Generator>", 3);
-            (*this->BuildFileStream) << cmVS10EscapeXML(generator)
-                                     << "</Generator>\n";
+            e2.Element("Generator", generator);
             if (designerResource.find(srcDir) == 0) {
               designerResource = designerResource.substr(srcDir.length() + 1);
             } else if (designerResource.find(binDir) == 0) {
@@ -770,9 +887,7 @@ void cmVisualStudio10TargetGenerator::WriteEmbeddedResourceGroup()
                 cmsys::SystemTools::GetFilenameName(designerResource);
             }
             ConvertToWindowsSlash(designerResource);
-            this->WriteString("<LastGenOutput>", 3);
-            (*this->BuildFileStream) << designerResource
-                                     << "</LastGenOutput>\n";
+            e2.Element("LastGenOutput", designerResource);
           }
         }
         const cmPropertyMap& props = oi->GetProperties();
@@ -783,31 +898,25 @@ void cmVisualStudio10TargetGenerator::WriteEmbeddedResourceGroup()
             if (!tagName.empty()) {
               std::string value = props.GetPropertyValue(p.first);
               if (!value.empty()) {
-                this->WriteString("<", 3);
-                (*this->BuildFileStream) << tagName << ">";
-                (*this->BuildFileStream) << cmVS10EscapeXML(value);
-                (*this->BuildFileStream) << "</" << tagName << ">\n";
+                e2.Element(tagName.c_str(), value);
               }
             }
           }
         }
       }
-
-      this->WriteString("</EmbeddedResource>\n", 2);
     }
-    this->WriteString("</ItemGroup>\n", 1);
   }
 }
 
-void cmVisualStudio10TargetGenerator::WriteXamlFilesGroup()
+void cmVisualStudio10TargetGenerator::WriteXamlFilesGroup(Elem& e0)
 {
   std::vector<cmSourceFile const*> xamlObjs;
   this->GeneratorTarget->GetXamlSources(xamlObjs, "");
   if (!xamlObjs.empty()) {
-    this->WriteString("<ItemGroup>\n", 1);
+    Elem e1(e0, "ItemGroup");
     for (cmSourceFile const* oi : xamlObjs) {
       std::string obj = oi->GetFullPath();
-      std::string xamlType;
+      const char* xamlType;
       const char* xamlTypeProperty = oi->GetProperty("VS_XAML_TYPE");
       if (xamlTypeProperty) {
         xamlType = xamlTypeProperty;
@@ -815,7 +924,9 @@ void cmVisualStudio10TargetGenerator::WriteXamlFilesGroup()
         xamlType = "Page";
       }
 
-      this->WriteSource(xamlType, oi, ">\n");
+      Elem e2(e1);
+      this->WriteSource(e2, xamlType, oi);
+      e2.SetHasElements();
       if (this->ProjectType == csproj && !this->InSourceBuild) {
         // add <Link> tag to written XAML source if necessary
         const std::string srcDir = this->Makefile->GetCurrentSourceDirectory();
@@ -830,58 +941,51 @@ void cmVisualStudio10TargetGenerator::WriteXamlFilesGroup()
         }
         if (!link.empty()) {
           ConvertToWindowsSlash(link);
-          this->WriteString("<Link>", 3);
-          (*this->BuildFileStream) << link << "</Link>\n";
+          e2.Element("Link", link);
         }
       }
-      this->WriteString("<SubType>Designer</SubType>\n", 3);
-      this->WriteString("</", 2);
-      (*this->BuildFileStream) << xamlType << ">\n";
+      e2.Element("SubType", "Designer");
     }
-    this->WriteString("</ItemGroup>\n", 1);
   }
 }
 
-void cmVisualStudio10TargetGenerator::WriteTargetSpecificReferences()
+void cmVisualStudio10TargetGenerator::WriteTargetSpecificReferences(Elem& e0)
 {
   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);
+      Elem(e0, "Import")
+        .Attribute("Project",
+                   "$(MSBuildExtensionsPath)\\Microsoft\\WindowsPhone\\v"
+                   "$(TargetPlatformVersion)\\Microsoft.Cpp.WindowsPhone."
+                   "$(TargetPlatformVersion).targets");
     }
   }
 }
 
-void cmVisualStudio10TargetGenerator::WriteTargetsFileReferences()
+void cmVisualStudio10TargetGenerator::WriteTargetsFileReferences(Elem& e1)
 {
-  for (std::vector<TargetsFileAndConfigs>::iterator i =
-         this->TargetsFileAndConfigsVec.begin();
-       i != this->TargetsFileAndConfigsVec.end(); ++i) {
-    TargetsFileAndConfigs const& tac = *i;
-    this->WriteString("<Import Project=\"", 3);
-    (*this->BuildFileStream) << tac.File << "\" ";
-    (*this->BuildFileStream) << "Condition=\"";
-    (*this->BuildFileStream) << "Exists('" << tac.File << "')";
+  for (TargetsFileAndConfigs const& tac : this->TargetsFileAndConfigsVec) {
+    std::ostringstream oss;
+    oss << "Exists('" << tac.File << "')";
     if (!tac.Configs.empty()) {
-      (*this->BuildFileStream) << " And (";
+      oss << " And (";
       for (size_t j = 0; j < tac.Configs.size(); ++j) {
         if (j > 0) {
-          (*this->BuildFileStream) << " Or ";
+          oss << " Or ";
         }
-        (*this->BuildFileStream) << "'$(Configuration)'=='" << tac.Configs[j]
-                                 << "'";
+        oss << "'$(Configuration)'=='" << tac.Configs[j] << "'";
       }
-      (*this->BuildFileStream) << ")";
+      oss << ")";
     }
-    (*this->BuildFileStream) << "\" />\n";
+
+    Elem(e1, "Import")
+      .Attribute("Project", tac.File)
+      .Attribute("Condition", oss.str());
   }
 }
 
-void cmVisualStudio10TargetGenerator::WriteWinRTReferences()
+void cmVisualStudio10TargetGenerator::WriteWinRTReferences(Elem& e0)
 {
   std::vector<std::string> references;
   if (const char* vsWinRTReferences =
@@ -895,77 +999,67 @@ void cmVisualStudio10TargetGenerator::WriteWinRTReferences()
     references.push_back("platform.winmd");
   }
   if (!references.empty()) {
-    this->WriteString("<ItemGroup>\n", 1);
-    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);
+    Elem e1(e0, "ItemGroup");
+    for (std::string const& ri : references) {
+      Elem e2(e1, "Reference");
+      e2.Attribute("Include", ri);
+      e2.Element("IsWinMDFile", "true");
     }
-    this->WriteString("</ItemGroup>\n", 1);
   }
 }
 
 // ConfigurationType Application, Utility StaticLibrary DynamicLibrary
 
-void cmVisualStudio10TargetGenerator::WriteProjectConfigurations()
+void cmVisualStudio10TargetGenerator::WriteProjectConfigurations(Elem& e0)
 {
-  this->WriteString("<ItemGroup Label=\"ProjectConfigurations\">\n", 1);
-  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->WriteString("<Configuration>", 3);
-    (*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);
+  Elem e1(e0, "ItemGroup");
+  e1.Attribute("Label", "ProjectConfigurations");
+  for (std::string const& c : this->Configurations) {
+    Elem e2(e1, "ProjectConfiguration");
+    e2.Attribute("Include", c + "|" + this->Platform);
+    e2.Element("Configuration", c);
+    e2.Element("Platform", this->Platform);
+  }
 }
 
-void cmVisualStudio10TargetGenerator::WriteProjectConfigurationValues()
+void cmVisualStudio10TargetGenerator::WriteProjectConfigurationValues(Elem& e0)
 {
-  for (std::vector<std::string>::const_iterator i =
-         this->Configurations.begin();
-       i != this->Configurations.end(); ++i) {
-    this->WritePlatformConfigTag("PropertyGroup", *i, 1,
-                                 " Label=\"Configuration\"", "\n");
+  for (std::string const& c : this->Configurations) {
+    Elem e1(e0, "PropertyGroup");
+    e1.Attribute("Condition", this->CalcCondition(c));
+    e1.Attribute("Label", "Configuration");
 
     if (this->ProjectType != csproj) {
-      std::string configType = "<ConfigurationType>";
+      std::string configType;
       if (const char* vsConfigurationType =
             this->GeneratorTarget->GetProperty("VS_CONFIGURATION_TYPE")) {
-        configType += cmVS10EscapeXML(vsConfigurationType);
+        configType = vsConfigurationType;
       } else {
         switch (this->GeneratorTarget->GetType()) {
           case cmStateEnums::SHARED_LIBRARY:
           case cmStateEnums::MODULE_LIBRARY:
-            configType += "DynamicLibrary";
+            configType = "DynamicLibrary";
             break;
           case cmStateEnums::OBJECT_LIBRARY:
           case cmStateEnums::STATIC_LIBRARY:
-            configType += "StaticLibrary";
+            configType = "StaticLibrary";
             break;
           case cmStateEnums::EXECUTABLE:
             if (this->NsightTegra &&
                 !this->GeneratorTarget->GetPropertyAsBool("ANDROID_GUI")) {
               // Android executables are .so too.
-              configType += "DynamicLibrary";
+              configType = "DynamicLibrary";
             } else {
-              configType += "Application";
+              configType = "Application";
             }
             break;
           case cmStateEnums::UTILITY:
           case cmStateEnums::GLOBAL_TARGET:
             if (this->NsightTegra) {
               // Tegra-Android platform does not understand "Utility".
-              configType += "StaticLibrary";
+              configType = "StaticLibrary";
             } else {
-              configType += "Utility";
+              configType = "Utility";
             }
             break;
           case cmStateEnums::UNKNOWN_LIBRARY:
@@ -973,32 +1067,26 @@ void cmVisualStudio10TargetGenerator::WriteProjectConfigurationValues()
             break;
         }
       }
-      configType += "</ConfigurationType>\n";
-      this->WriteString(configType.c_str(), 2);
+      e1.Element("ConfigurationType", configType);
     }
 
     if (this->MSTools) {
       if (!this->Managed) {
-        this->WriteMSToolConfigurationValues(*i);
+        this->WriteMSToolConfigurationValues(e1, c);
       } else {
-        this->WriteMSToolConfigurationValuesManaged(*i);
+        this->WriteMSToolConfigurationValuesManaged(e1, c);
       }
     } else if (this->NsightTegra) {
-      this->WriteNsightTegraConfigurationValues(*i);
+      this->WriteNsightTegraConfigurationValues(e1, c);
     }
-
-    this->WriteString("</PropertyGroup>\n", 1);
   }
 }
 
 void cmVisualStudio10TargetGenerator::WriteMSToolConfigurationValues(
-  std::string const& config)
+  Elem& e1, std::string const& config)
 {
-  cmGlobalVisualStudio10Generator* gg =
-    static_cast<cmGlobalVisualStudio10Generator*>(this->GlobalGenerator);
-  const char* mfcFlag =
-    this->GeneratorTarget->Target->GetMakefile()->GetDefinition(
-      "CMAKE_MFC_FLAG");
+  cmGlobalVisualStudio10Generator* gg = this->GlobalGenerator;
+  const char* mfcFlag = this->Makefile->GetDefinition("CMAKE_MFC_FLAG");
   if (mfcFlag) {
     std::string const mfcFlagValue = mfcFlag;
 
@@ -1010,9 +1098,7 @@ void cmVisualStudio10TargetGenerator::WriteMSToolConfigurationValues(
         useOfMfcValue = "Dynamic";
       }
     }
-    std::string mfcLine = "<UseOfMfc>";
-    mfcLine += useOfMfcValue + "</UseOfMfc>\n";
-    this->WriteString(mfcLine.c_str(), 2);
+    e1.Element("UseOfMfc", useOfMfcValue);
   }
 
   if ((this->GeneratorTarget->GetType() <= cmStateEnums::OBJECT_LIBRARY &&
@@ -1021,57 +1107,46 @@ void cmVisualStudio10TargetGenerator::WriteMSToolConfigurationValues(
       this->GlobalGenerator->TargetsWindowsPhone() ||
       this->GlobalGenerator->TargetsWindowsStore() ||
       this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_EXTENSIONS")) {
-    this->WriteString("<CharacterSet>Unicode</CharacterSet>\n", 2);
+    e1.Element("CharacterSet", "Unicode");
   } else if (this->GeneratorTarget->GetType() <=
                cmStateEnums::MODULE_LIBRARY &&
              this->ClOptions[config]->UsingSBCS()) {
-    this->WriteString("<CharacterSet>NotSet</CharacterSet>\n", 2);
+    e1.Element("CharacterSet", "NotSet");
   } else {
-    this->WriteString("<CharacterSet>MultiByte</CharacterSet>\n", 2);
+    e1.Element("CharacterSet", "MultiByte");
   }
   if (const char* toolset = gg->GetPlatformToolset()) {
-    std::string pts = "<PlatformToolset>";
-    pts += toolset;
-    pts += "</PlatformToolset>\n";
-    this->WriteString(pts.c_str(), 2);
+    e1.Element("PlatformToolset", toolset);
   }
   if (this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_COMPONENT") ||
       this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_EXTENSIONS")) {
-    this->WriteString("<WindowsAppContainer>true"
-                      "</WindowsAppContainer>\n",
-                      2);
+    e1.Element("WindowsAppContainer", "true");
   }
 }
 
 void cmVisualStudio10TargetGenerator::WriteMSToolConfigurationValuesManaged(
-  std::string const& config)
+  Elem& e1, std::string const& config)
 {
-  cmGlobalVisualStudio10Generator* gg =
-    static_cast<cmGlobalVisualStudio10Generator*>(this->GlobalGenerator);
+  cmGlobalVisualStudio10Generator* gg = this->GlobalGenerator;
 
   Options& o = *(this->ClOptions[config]);
 
   if (o.IsDebug()) {
-    this->WriteString("<DebugSymbols>true</DebugSymbols>\n", 2);
-    this->WriteString("<DefineDebug>true</DefineDebug>\n", 2);
+    e1.Element("DebugSymbols", "true");
+    e1.Element("DefineDebug", "true");
   }
 
   std::string outDir = this->GeneratorTarget->GetDirectory(config) + "/";
   ConvertToWindowsSlash(outDir);
-  this->WriteString("<OutputPath>", 2);
-  (*this->BuildFileStream) << cmVS10EscapeXML(outDir) << "</OutputPath>\n";
+  e1.Element("OutputPath", outDir);
 
   if (o.HasFlag("Platform")) {
-    this->WriteString("<PlatformTarget>", 2);
-    (*this->BuildFileStream) << cmVS10EscapeXML(o.GetFlag("Platform"))
-                             << "</PlatformTarget>\n";
+    e1.Element("PlatformTarget", o.GetFlag("Platform"));
     o.RemoveFlag("Platform");
   }
 
   if (const char* toolset = gg->GetPlatformToolset()) {
-    this->WriteString("<PlatformToolset>", 2);
-    (*this->BuildFileStream) << cmVS10EscapeXML(toolset)
-                             << "</PlatformToolset>\n";
+    e1.Element("PlatformToolset", toolset);
   }
 
   std::string postfixName = cmSystemTools::UpperCase(config);
@@ -1081,68 +1156,50 @@ void cmVisualStudio10TargetGenerator::WriteMSToolConfigurationValuesManaged(
   if (const char* postfix = this->GeneratorTarget->GetProperty(postfixName)) {
     assemblyName += postfix;
   }
-  this->WriteString("<AssemblyName>", 2);
-  (*this->BuildFileStream) << cmVS10EscapeXML(assemblyName)
-                           << "</AssemblyName>\n";
+  e1.Element("AssemblyName", assemblyName);
 
   if (cmStateEnums::EXECUTABLE == this->GeneratorTarget->GetType()) {
-    this->WriteString("<StartAction>Program</StartAction>\n", 2);
-    this->WriteString("<StartProgram>", 2);
-    (*this->BuildFileStream) << cmVS10EscapeXML(outDir)
-                             << cmVS10EscapeXML(assemblyName)
-                             << ".exe</StartProgram>\n";
+    e1.Element("StartAction", "Program");
+    e1.Element("StartProgram", outDir + assemblyName + ".exe");
   }
 
-  o.OutputFlagMap(*this->BuildFileStream, "    ");
+  OptionsHelper oh(o, e1);
+  oh.OutputFlagMap();
 }
 
 //----------------------------------------------------------------------------
 void cmVisualStudio10TargetGenerator::WriteNsightTegraConfigurationValues(
-  std::string const&)
+  Elem& e1, std::string const&)
 {
-  cmGlobalVisualStudio10Generator* gg =
-    static_cast<cmGlobalVisualStudio10Generator*>(this->GlobalGenerator);
+  cmGlobalVisualStudio10Generator* gg = this->GlobalGenerator;
   const char* toolset = gg->GetPlatformToolset();
-  std::string ntv = "<NdkToolchainVersion>";
-  ntv += toolset ? toolset : "Default";
-  ntv += "</NdkToolchainVersion>\n";
-  this->WriteString(ntv.c_str(), 2);
+  e1.Element("NdkToolchainVersion", toolset ? toolset : "Default");
   if (const char* minApi =
         this->GeneratorTarget->GetProperty("ANDROID_API_MIN")) {
-    this->WriteString("<AndroidMinAPI>", 2);
-    (*this->BuildFileStream) << "android-" << cmVS10EscapeXML(minApi)
-                             << "</AndroidMinAPI>\n";
+    e1.Element("AndroidMinAPI", "android-" + std::string(minApi));
   }
   if (const char* api = this->GeneratorTarget->GetProperty("ANDROID_API")) {
-    this->WriteString("<AndroidTargetAPI>", 2);
-    (*this->BuildFileStream) << "android-" << cmVS10EscapeXML(api)
-                             << "</AndroidTargetAPI>\n";
+    e1.Element("AndroidTargetAPI", "android-" + std::string(api));
   }
 
   if (const char* cpuArch =
         this->GeneratorTarget->GetProperty("ANDROID_ARCH")) {
-    this->WriteString("<AndroidArch>", 2);
-    (*this->BuildFileStream) << cmVS10EscapeXML(cpuArch) << "</AndroidArch>\n";
+    e1.Element("AndroidArch", cpuArch);
   }
 
   if (const char* stlType =
         this->GeneratorTarget->GetProperty("ANDROID_STL_TYPE")) {
-    this->WriteString("<AndroidStlType>", 2);
-    (*this->BuildFileStream) << cmVS10EscapeXML(stlType)
-                             << "</AndroidStlType>\n";
+    e1.Element("AndroidStlType", stlType);
   }
 }
 
-void cmVisualStudio10TargetGenerator::WriteCustomCommands()
+void cmVisualStudio10TargetGenerator::WriteCustomCommands(Elem& e0)
 {
-  this->SourcesVisited.clear();
   this->CSharpCustomCommandNames.clear();
   std::vector<cmSourceFile const*> customCommands;
   this->GeneratorTarget->GetCustomCommands(customCommands, "");
-  for (std::vector<cmSourceFile const*>::const_iterator si =
-         customCommands.begin();
-       si != customCommands.end(); ++si) {
-    this->WriteCustomCommand(*si);
+  for (cmSourceFile const* si : customCommands) {
+    this->WriteCustomCommand(e0, si);
   }
 
   // Add CMakeLists.txt file with rule to re-run CMake for user convenience.
@@ -1150,46 +1207,41 @@ void cmVisualStudio10TargetGenerator::WriteCustomCommands()
       this->GeneratorTarget->GetName() != CMAKE_CHECK_BUILD_SYSTEM_TARGET) {
     if (cmSourceFile const* sf =
           this->LocalGenerator->CreateVCProjBuildRule()) {
-      this->WriteCustomCommand(sf);
+      this->WriteCustomCommand(e0, sf);
     }
   }
 }
 
 void cmVisualStudio10TargetGenerator::WriteCustomCommand(
-  cmSourceFile const* sf)
+  Elem& e0, cmSourceFile const* sf)
 {
-  if (this->SourcesVisited.insert(sf).second) {
+  if (this->LocalGenerator->GetSourcesVisited(this->GeneratorTarget)
+        .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);
+      for (cmSourceFile const* di : *depends) {
+        this->WriteCustomCommand(e0, di);
       }
     }
     if (cmCustomCommand const* command = sf->GetCustomCommand()) {
       // C# projects write their <Target> within WriteCustomRule()
-      if (this->ProjectType != csproj) {
-        this->WriteString("<ItemGroup>\n", 1);
-      }
-      this->WriteCustomRule(sf, *command);
-      if (this->ProjectType != csproj) {
-        this->WriteString("</ItemGroup>\n", 1);
-      }
+      this->WriteCustomRule(e0, sf, *command);
     }
   }
 }
 
 void cmVisualStudio10TargetGenerator::WriteCustomRule(
-  cmSourceFile const* source, cmCustomCommand const& command)
+  Elem& e0, 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 (!cmSystemTools::FileExists(sourcePath)) {
       // Make sure the path exists for the file
       std::string path = cmSystemTools::GetFilenamePath(sourcePath);
-      cmSystemTools::MakeDirectory(path.c_str());
+      cmSystemTools::MakeDirectory(path);
       cmsys::ofstream fout(sourcePath.c_str());
       if (fout) {
         fout << "# generated from CMake\n";
@@ -1209,111 +1261,93 @@ void cmVisualStudio10TargetGenerator::WriteCustomRule(
   }
   cmLocalVisualStudio7Generator* lg = this->LocalGenerator;
 
+  std::unique_ptr<Elem> spe1;
+  std::unique_ptr<Elem> spe2;
   if (this->ProjectType != csproj) {
-    this->WriteSource("CustomBuild", source, ">\n");
+    spe1 = cm::make_unique<Elem>(e0, "ItemGroup");
+    spe2 = cm::make_unique<Elem>(*spe1);
+    this->WriteSource(*spe2, "CustomBuild", source);
+    spe2->SetHasElements();
   } else {
-    this->WriteString("<ItemGroup>\n", 1);
+    Elem e1(e0, "ItemGroup");
+    Elem e2(e1);
     std::string link;
     this->GetCSharpSourceLink(source, link);
-    this->WriteSource("None", source, ">\n");
+    this->WriteSource(e2, "None", source);
+    e2.SetHasElements();
     if (!link.empty()) {
-      this->WriteString("<Link>", 3);
-      (*this->BuildFileStream) << link << "</Link>\n";
+      e2.Element("Link", link);
     }
-    this->WriteString("</None>\n", 2);
-    this->WriteString("</ItemGroup>\n", 1);
   }
-  for (std::vector<std::string>::const_iterator i =
-         this->Configurations.begin();
-       i != this->Configurations.end(); ++i) {
-    cmCustomCommandGenerator ccg(command, *i, this->LocalGenerator);
+  for (std::string const& c : this->Configurations) {
+    cmCustomCommandGenerator ccg(command, c, lg);
     std::string comment = lg->ConstructComment(ccg);
     comment = cmVS10EscapeComment(comment);
-    std::string script = cmVS10EscapeXML(lg->ConstructScript(ccg));
+    std::string script = lg->ConstructScript(ccg);
     // input files for custom command
     std::stringstream inputs;
-    inputs << cmVS10EscapeXML(source->GetFullPath());
-    for (std::vector<std::string>::const_iterator d = ccg.GetDepends().begin();
-         d != ccg.GetDepends().end(); ++d) {
+    inputs << source->GetFullPath();
+    for (std::string const& d : ccg.GetDepends()) {
       std::string dep;
-      if (this->LocalGenerator->GetRealDependency(*d, *i, dep)) {
+      if (lg->GetRealDependency(d, c, dep)) {
         ConvertToWindowsSlash(dep);
-        inputs << ";" << cmVS10EscapeXML(dep);
+        inputs << ";" << dep;
       }
     }
     // output files for custom command
     std::stringstream outputs;
     const char* sep = "";
-    for (std::vector<std::string>::const_iterator o = ccg.GetOutputs().begin();
-         o != ccg.GetOutputs().end(); ++o) {
-      std::string out = *o;
+    for (std::string const& o : ccg.GetOutputs()) {
+      std::string out = o;
       ConvertToWindowsSlash(out);
-      outputs << sep << cmVS10EscapeXML(out);
+      outputs << sep << out;
       sep = ";";
     }
     if (this->ProjectType == csproj) {
-      std::string name = "CustomCommand_" + *i + "_" +
+      std::string name = "CustomCommand_" + c + "_" +
         cmSystemTools::ComputeStringMD5(sourcePath);
-      std::string inputs_s = inputs.str();
-      std::string outputs_s = outputs.str();
-      comment = cmVS10EscapeQuotes(comment);
-      script = cmVS10EscapeQuotes(script);
-      inputs_s = cmVS10EscapeQuotes(inputs_s);
-      outputs_s = cmVS10EscapeQuotes(outputs_s);
-      this->WriteCustomRuleCSharp(*i, name, script, inputs_s, outputs_s,
-                                  comment);
+      this->WriteCustomRuleCSharp(e0, c, name, script, inputs.str(),
+                                  outputs.str(), comment);
     } else {
-      this->WriteCustomRuleCpp(*i, script, inputs.str(), outputs.str(),
+      this->WriteCustomRuleCpp(*spe2, c, script, inputs.str(), outputs.str(),
                                comment);
     }
   }
-  if (this->ProjectType != csproj) {
-    this->WriteString("</CustomBuild>\n", 2);
-  }
 }
 
 void cmVisualStudio10TargetGenerator::WriteCustomRuleCpp(
-  std::string const& config, std::string const& script,
+  Elem& e2, std::string const& config, std::string const& script,
   std::string const& inputs, std::string const& outputs,
   std::string const& comment)
 {
-  this->WritePlatformConfigTag("Message", config, 3);
-  (*this->BuildFileStream) << cmVS10EscapeXML(comment) << "</Message>\n";
-  this->WritePlatformConfigTag("Command", config, 3);
-  (*this->BuildFileStream) << script << "</Command>\n";
-  this->WritePlatformConfigTag("AdditionalInputs", config, 3);
-  (*this->BuildFileStream) << inputs;
-  (*this->BuildFileStream) << ";%(AdditionalInputs)</AdditionalInputs>\n";
-  this->WritePlatformConfigTag("Outputs", config, 3);
-  (*this->BuildFileStream) << outputs << "</Outputs>\n";
+  const std::string cond = this->CalcCondition(config);
+  e2.WritePlatformConfigTag("Message", cond, comment);
+  e2.WritePlatformConfigTag("Command", cond, script);
+  e2.WritePlatformConfigTag("AdditionalInputs", cond,
+                            inputs + ";%(AdditionalInputs)");
+  e2.WritePlatformConfigTag("Outputs", cond, outputs);
   if (this->LocalGenerator->GetVersion() >
       cmGlobalVisualStudioGenerator::VS10) {
     // VS >= 11 let us turn off linking of custom command outputs.
-    this->WritePlatformConfigTag("LinkObjects", config, 3);
-    (*this->BuildFileStream) << "false</LinkObjects>\n";
+    e2.WritePlatformConfigTag("LinkObjects", cond, "false");
   }
 }
 
 void cmVisualStudio10TargetGenerator::WriteCustomRuleCSharp(
-  std::string const& config, std::string const& name,
+  Elem& e0, std::string const& config, std::string const& name,
   std::string const& script, std::string const& inputs,
   std::string const& outputs, std::string const& comment)
 {
   this->CSharpCustomCommandNames.insert(name);
-  std::stringstream attributes;
-  attributes << "\n    Name=\"" << name << "\"";
-  attributes << "\n    Inputs=\"" << inputs << "\"";
-  attributes << "\n    Outputs=\"" << outputs << "\"";
-  this->WritePlatformConfigTag("Target", config, 1, attributes.str().c_str(),
-                               "\n");
+  Elem e1(e0, "Target");
+  e1.Attribute("Condition", this->CalcCondition(config));
+  e1.S << "\n    Name=\"" << name << "\"";
+  e1.S << "\n    Inputs=\"" << cmVS10EscapeAttr(inputs) << "\"";
+  e1.S << "\n    Outputs=\"" << cmVS10EscapeAttr(outputs) << "\"";
   if (!comment.empty()) {
-    this->WriteString("<Exec Command=\"", 2);
-    (*this->BuildFileStream) << "echo " << cmVS10EscapeXML(comment)
-                             << "\" />\n";
+    Elem(e1, "Exec").Attribute("Command", "echo " + comment);
   }
-  this->WriteString("<Exec Command=\"", 2);
-  (*this->BuildFileStream) << script << "\" />\n";
-  this->WriteString("</Target>\n", 1);
+  Elem(e1, "Exec").Attribute("Command", script);
 }
 
 std::string cmVisualStudio10TargetGenerator::ConvertPath(
@@ -1321,8 +1355,8 @@ std::string cmVisualStudio10TargetGenerator::ConvertPath(
 {
   return forceRelative
     ? cmSystemTools::RelativePath(
-        this->LocalGenerator->GetCurrentBinaryDirectory(), path.c_str())
-    : path.c_str();
+        this->LocalGenerator->GetCurrentBinaryDirectory(), path)
+    : path;
 }
 
 static void ConvertToWindowsSlash(std::string& s)
@@ -1334,6 +1368,7 @@ static void ConvertToWindowsSlash(std::string& s)
     pos++;
   }
 }
+
 void cmVisualStudio10TargetGenerator::WriteGroups()
 {
   if (this->ProjectType == csproj) {
@@ -1347,10 +1382,8 @@ void cmVisualStudio10TargetGenerator::WriteGroups()
     this->GeneratorTarget->GetAllConfigSources();
 
   std::set<cmSourceGroup*> groupsUsed;
-  for (std::vector<cmGeneratorTarget::AllConfigSource>::const_iterator si =
-         sources.begin();
-       si != sources.end(); ++si) {
-    std::string const& source = si->Source->GetFullPath();
+  for (cmGeneratorTarget::AllConfigSource const& si : sources) {
+    std::string const& source = si.Source->GetFullPath();
     cmSourceGroup* sourceGroup =
       this->Makefile->FindSourceGroup(source, sourceGroups);
     groupsUsed.insert(sourceGroup);
@@ -1369,109 +1402,94 @@ void cmVisualStudio10TargetGenerator::WriteGroups()
   fout.SetCopyIfDifferent(true);
   char magic[] = { char(0xEF), char(0xBB), char(0xBF) };
   fout.write(magic, 3);
-  cmGeneratedFileStream* save = this->BuildFileStream;
-  this->BuildFileStream = &fout;
-
-  // get the tools version to use
-  const std::string toolsVer(this->GlobalGenerator->GetToolsVersion());
-  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(
-    "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) {
-    this->WriteGroupSources(ti->first.c_str(), ti->second, sourceGroups);
-  }
-
-  // Added files are images and the manifest.
-  if (!this->AddedFiles.empty()) {
-    this->WriteString("<ItemGroup>\n", 1);
-    for (std::string const& oi : this->AddedFiles) {
-      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") {
-        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") {
-        this->WriteString("<None Include=\"", 2);
-        (*this->BuildFileStream) << oi << "\">\n";
-        this->WriteString("<Filter>Resource Files</Filter>\n", 3);
-        this->WriteString("</None>\n", 2);
-      } else {
-        this->WriteString("<Image Include=\"", 2);
-        (*this->BuildFileStream) << oi << "\">\n";
-        this->WriteString("<Filter>Resource Files</Filter>\n", 3);
-        this->WriteString("</Image>\n", 2);
+
+  fout << "<?xml version=\"1.0\" encoding=\""
+       << this->GlobalGenerator->Encoding() << "\"?>"
+       << "\n";
+  {
+    Elem e0(fout);
+    e0.StartElement("Project");
+    e0.Attribute("ToolsVersion", this->GlobalGenerator->GetToolsVersion());
+    e0.Attribute("xmlns",
+                 "http://schemas.microsoft.com/developer/msbuild/2003");
+
+    for (auto const& ti : this->Tools) {
+      this->WriteGroupSources(e0, ti.first, ti.second, sourceGroups);
+    }
+
+    // Added files are images and the manifest.
+    if (!this->AddedFiles.empty()) {
+      Elem e1(e0, "ItemGroup");
+      e1.SetHasElements();
+      for (std::string const& oi : this->AddedFiles) {
+        std::string fileName =
+          cmSystemTools::LowerCase(cmSystemTools::GetFilenameName(oi));
+        if (fileName == "wmappmanifest.xml") {
+          Elem e2(e1, "XML");
+          e2.Attribute("Include", oi);
+          e2.Element("Filter", "Resource Files");
+        } else if (cmSystemTools::GetFilenameExtension(fileName) ==
+                   ".appxmanifest") {
+          Elem e2(e1, "AppxManifest");
+          e2.Attribute("Include", oi);
+          e2.Element("Filter", "Resource Files");
+        } else if (cmSystemTools::GetFilenameExtension(fileName) == ".pfx") {
+          Elem e2(e1, "None");
+          e2.Attribute("Include", oi);
+          e2.Element("Filter", "Resource Files");
+        } else {
+          Elem e2(e1, "Image");
+          e2.Attribute("Include", oi);
+          e2.Element("Filter", "Resource Files");
+        }
       }
     }
-    this->WriteString("</ItemGroup>\n", 1);
-  }
 
-  std::vector<cmSourceFile const*> resxObjs;
-  this->GeneratorTarget->GetResxSources(resxObjs, "");
-  if (!resxObjs.empty()) {
-    this->WriteString("<ItemGroup>\n", 1);
-    for (cmSourceFile const* oi : resxObjs) {
-      std::string obj = oi->GetFullPath();
-      this->WriteString("<EmbeddedResource Include=\"", 2);
-      ConvertToWindowsSlash(obj);
-      (*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);
-  std::vector<cmSourceGroup*> groupsVec(groupsUsed.begin(), groupsUsed.end());
-  std::sort(groupsVec.begin(), groupsVec.end(),
-            [](cmSourceGroup* l, cmSourceGroup* r) {
-              return l->GetFullName() < r->GetFullName();
-            });
-  for (cmSourceGroup* sg : groupsVec) {
-    std::string const& name = sg->GetFullName();
-    if (!name.empty()) {
-      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);
-      (*this->BuildFileStream) << "{" << guid << "}"
-                               << "</UniqueIdentifier>\n";
-      this->WriteString("</Filter>\n", 2);
-    }
-  }
-
-  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);
-    (*this->BuildFileStream) << "{" << guid << "}"
-                             << "</UniqueIdentifier>\n";
-    this->WriteString("<Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;", 3);
-    (*this->BuildFileStream) << "gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;";
-    (*this->BuildFileStream) << "mfcribbon-ms</Extensions>\n";
-    this->WriteString("</Filter>\n", 2);
-  }
-
-  this->WriteString("</ItemGroup>\n", 1);
-  this->WriteString("</Project>\n", 0);
-  // restore stream pointer
-  this->BuildFileStream = save;
+    std::vector<cmSourceFile const*> resxObjs;
+    this->GeneratorTarget->GetResxSources(resxObjs, "");
+    if (!resxObjs.empty()) {
+      Elem e1(e0, "ItemGroup");
+      for (cmSourceFile const* oi : resxObjs) {
+        std::string obj = oi->GetFullPath();
+        ConvertToWindowsSlash(obj);
+        Elem e2(e1, "EmbeddedResource");
+        e2.Attribute("Include", obj);
+        e2.Element("Filter", "Resource Files");
+      }
+    }
+    {
+      Elem e1(e0, "ItemGroup");
+      e1.SetHasElements();
+      std::vector<cmSourceGroup*> groupsVec(groupsUsed.begin(),
+                                            groupsUsed.end());
+      std::sort(groupsVec.begin(), groupsVec.end(),
+                [](cmSourceGroup* l, cmSourceGroup* r) {
+                  return l->GetFullName() < r->GetFullName();
+                });
+      for (cmSourceGroup* sg : groupsVec) {
+        std::string const& name = sg->GetFullName();
+        if (!name.empty()) {
+          std::string guidName = "SG_Filter_" + name;
+          std::string guid = this->GlobalGenerator->GetGUID(guidName);
+          Elem e2(e1, "Filter");
+          e2.Attribute("Include", name);
+          e2.Element("UniqueIdentifier", "{" + guid + "}");
+        }
+      }
+
+      if (!resxObjs.empty() || !this->AddedFiles.empty()) {
+        std::string guidName = "SG_Filter_Resource Files";
+        std::string guid = this->GlobalGenerator->GetGUID(guidName);
+        Elem e2(e1, "Filter");
+        e2.Attribute("Include", "Resource Files");
+        e2.Element("UniqueIdentifier", "{" + guid + "}");
+        e2.Element("Extensions",
+                   "rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;"
+                   "gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms");
+      }
+    }
+  }
+  fout << '\n';
 
   if (fout.Close()) {
     this->GlobalGenerator->FileReplacedDuringGenerate(path);
@@ -1516,61 +1534,53 @@ void cmVisualStudio10TargetGenerator::AddMissingSourceGroups(
 }
 
 void cmVisualStudio10TargetGenerator::WriteGroupSources(
-  const char* name, ToolSources const& sources,
+  Elem& e0, std::string const& name, ToolSources const& sources,
   std::vector<cmSourceGroup>& sourceGroups)
 {
-  this->WriteString("<ItemGroup>\n", 1);
+  Elem e1(e0, "ItemGroup");
+  e1.SetHasElements();
   for (ToolSource const& s : sources) {
     cmSourceFile const* sf = s.SourceFile;
     std::string const& source = sf->GetFullPath();
     cmSourceGroup* sourceGroup =
       this->Makefile->FindSourceGroup(source, sourceGroups);
     std::string const& filter = sourceGroup->GetFullName();
-    this->WriteString("<", 2);
     std::string path = this->ConvertPath(source, s.RelativePath);
     ConvertToWindowsSlash(path);
-    (*this->BuildFileStream) << name << " Include=\"" << cmVS10EscapeXML(path);
+    Elem e2(e1, name.c_str());
+    e2.Attribute("Include", path);
     if (!filter.empty()) {
-      (*this->BuildFileStream) << "\">\n";
-      this->WriteString("<Filter>", 3);
-      (*this->BuildFileStream) << filter << "</Filter>\n";
-      this->WriteString("</", 2);
-      (*this->BuildFileStream) << name << ">\n";
-    } else {
-      (*this->BuildFileStream) << "\" />\n";
+      e2.Element("Filter", filter);
     }
   }
-  this->WriteString("</ItemGroup>\n", 1);
 }
 
-void cmVisualStudio10TargetGenerator::WriteHeaderSource(cmSourceFile const* sf)
+void cmVisualStudio10TargetGenerator::WriteHeaderSource(Elem& e1,
+                                                        cmSourceFile const* sf)
 {
   std::string const& fileName = sf->GetFullPath();
+  Elem e2(e1);
+  this->WriteSource(e2, "ClInclude", sf);
   if (this->IsResxHeader(fileName)) {
-    this->WriteSource("ClInclude", sf, ">\n");
-    this->WriteString("<FileType>CppForm</FileType>\n", 3);
-    this->WriteString("</ClInclude>\n", 2);
+    e2.Element("FileType", "CppForm");
   } 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 {
-    this->WriteSource("ClInclude", sf);
+    e2.Element("DependentUpon", xamlFileName);
   }
 }
 
-void cmVisualStudio10TargetGenerator::WriteExtraSource(cmSourceFile const* sf)
+void cmVisualStudio10TargetGenerator::WriteExtraSource(Elem& e1,
+                                                       cmSourceFile const* sf)
 {
   bool toolHasSettings = false;
-  std::string tool = "None";
+  const char* tool = "None";
   std::string shaderType;
   std::string shaderEntryPoint;
   std::string shaderModel;
   std::string shaderAdditionalFlags;
   std::string shaderDisableOptimizations;
   std::string shaderEnableDebug;
+  std::string shaderObjectFileName;
   std::string outputHeaderFile;
   std::string variableName;
   std::string settingsGenerator;
@@ -1639,12 +1649,16 @@ void cmVisualStudio10TargetGenerator::WriteExtraSource(cmSourceFile const* sf)
     }
     // Figure out if debug information should be generated
     if (const char* sed = sf->GetProperty("VS_SHADER_ENABLE_DEBUG")) {
-      shaderEnableDebug = cmSystemTools::IsOn(sed) ? "true" : "false";
+      shaderEnableDebug = sed;
       toolHasSettings = true;
     }
     // Figure out if optimizations should be disabled
     if (const char* sdo = sf->GetProperty("VS_SHADER_DISABLE_OPTIMIZATIONS")) {
-      shaderDisableOptimizations = cmSystemTools::IsOn(sdo) ? "true" : "false";
+      shaderDisableOptimizations = sdo;
+      toolHasSettings = true;
+    }
+    if (const char* sofn = sf->GetProperty("VS_SHADER_OBJECT_FILE_NAME")) {
+      shaderObjectFileName = sofn;
       toolHasSettings = true;
     }
   } else if (ext == "jpg" || ext == "png") {
@@ -1714,8 +1728,10 @@ void cmVisualStudio10TargetGenerator::WriteExtraSource(cmSourceFile const* sf)
     }
   }
 
+  Elem e2(e1);
+  this->WriteSource(e2, tool, sf);
   if (toolHasSettings) {
-    this->WriteSource(tool, sf, ">\n");
+    e2.SetHasElements();
 
     if (!deployContent.empty()) {
       cmGeneratorExpression ge;
@@ -1723,123 +1739,120 @@ void cmVisualStudio10TargetGenerator::WriteExtraSource(cmSourceFile const* sf)
         ge.Parse(deployContent);
       // Deployment location cannot be set on a configuration basis
       if (!deployLocation.empty()) {
-        this->WriteString("<Link>", 3);
-        (*this->BuildFileStream) << deployLocation
-                                 << "\\%(FileName)%(Extension)";
-        this->WriteString("</Link>\n", 0);
+        e2.Element("Link", deployLocation + "\\%(FileName)%(Extension)");
       }
       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);
-          (*this->BuildFileStream) << this->Configurations[i] << "|"
-                                   << this->Platform << "'\">true";
-          this->WriteString("</DeploymentContent>\n", 0);
+        if (0 ==
+            strcmp(
+              cge->Evaluate(this->LocalGenerator, this->Configurations[i]),
+              "1")) {
+          e2.WritePlatformConfigTag("DeploymentContent",
+                                    "'$(Configuration)|$(Platform)'=='" +
+                                      this->Configurations[i] + "|" +
+                                      this->Platform + "'",
+                                    "true");
         } else {
-          this->WriteString("<ExcludedFromBuild Condition=\""
-                            "'$(Configuration)|$(Platform)'=='",
-                            3);
-          (*this->BuildFileStream) << this->Configurations[i] << "|"
-                                   << this->Platform << "'\">true";
-          this->WriteString("</ExcludedFromBuild>\n", 0);
+          e2.WritePlatformConfigTag("ExcludedFromBuild",
+                                    "'$(Configuration)|$(Platform)'=='" +
+                                      this->Configurations[i] + "|" +
+                                      this->Platform + "'",
+                                    "true");
         }
       }
     }
     if (!shaderType.empty()) {
-      this->WriteString("<ShaderType>", 3);
-      (*this->BuildFileStream) << cmVS10EscapeXML(shaderType)
-                               << "</ShaderType>\n";
+      e2.Element("ShaderType", shaderType);
     }
     if (!shaderEntryPoint.empty()) {
-      this->WriteString("<EntryPointName>", 3);
-      (*this->BuildFileStream) << cmVS10EscapeXML(shaderEntryPoint)
-                               << "</EntryPointName>\n";
+      e2.Element("EntryPointName", shaderEntryPoint);
     }
     if (!shaderModel.empty()) {
-      this->WriteString("<ShaderModel>", 3);
-      (*this->BuildFileStream) << cmVS10EscapeXML(shaderModel)
-                               << "</ShaderModel>\n";
+      e2.Element("ShaderModel", shaderModel);
     }
     if (!outputHeaderFile.empty()) {
       for (size_t i = 0; i != this->Configurations.size(); ++i) {
-        this->WriteString("<HeaderFileOutput Condition=\""
-                          "'$(Configuration)|$(Platform)'=='",
-                          3);
-        (*this->BuildFileStream) << this->Configurations[i] << "|"
-                                 << this->Platform << "'\">"
-                                 << cmVS10EscapeXML(outputHeaderFile);
-        this->WriteString("</HeaderFileOutput>\n", 0);
+        e2.WritePlatformConfigTag("HeaderFileOutput",
+                                  "'$(Configuration)|$(Platform)'=='" +
+                                    this->Configurations[i] + "|" +
+                                    this->Platform + "'",
+                                  outputHeaderFile);
       }
     }
     if (!variableName.empty()) {
       for (size_t i = 0; i != this->Configurations.size(); ++i) {
-        this->WriteString("<VariableName Condition=\""
-                          "'$(Configuration)|$(Platform)'=='",
-                          3);
-        (*this->BuildFileStream) << this->Configurations[i] << "|"
-                                 << this->Platform << "'\">"
-                                 << cmVS10EscapeXML(variableName);
-        this->WriteString("</VariableName>\n", 0);
+        e2.WritePlatformConfigTag("VariableName",
+                                  "'$(Configuration)|$(Platform)'=='" +
+                                    this->Configurations[i] + "|" +
+                                    this->Platform + "'",
+                                  variableName);
       }
     }
     if (!shaderEnableDebug.empty()) {
-      this->WriteString("<EnableDebuggingInformation>", 3);
-      (*this->BuildFileStream) << cmVS10EscapeXML(shaderEnableDebug)
-                               << "</EnableDebuggingInformation>\n";
+      cmGeneratorExpression ge;
+      std::unique_ptr<cmCompiledGeneratorExpression> cge =
+        ge.Parse(shaderEnableDebug);
+
+      for (size_t i = 0; i != this->Configurations.size(); ++i) {
+        const char* enableDebug =
+          cge->Evaluate(this->LocalGenerator, this->Configurations[i]);
+        if (strlen(enableDebug) > 0) {
+          e2.WritePlatformConfigTag(
+            "EnableDebuggingInformation",
+            "'$(Configuration)|$(Platform)'=='" + this->Configurations[i] +
+              "|" + this->Platform + "'",
+            cmSystemTools::IsOn(enableDebug) ? "true" : "false");
+        }
+      }
     }
     if (!shaderDisableOptimizations.empty()) {
-      this->WriteString("<DisableOptimizations>", 3);
-      (*this->BuildFileStream) << cmVS10EscapeXML(shaderDisableOptimizations)
-                               << "</DisableOptimizations>\n";
+      cmGeneratorExpression ge;
+      std::unique_ptr<cmCompiledGeneratorExpression> cge =
+        ge.Parse(shaderDisableOptimizations);
+
+      for (size_t i = 0; i != this->Configurations.size(); ++i) {
+        const char* disableOptimizations =
+          cge->Evaluate(this->LocalGenerator, this->Configurations[i]);
+        if (strlen(disableOptimizations) > 0) {
+          e2.WritePlatformConfigTag(
+            "DisableOptimizations",
+            "'$(Configuration)|$(Platform)'=='" + this->Configurations[i] +
+              "|" + this->Platform + "'",
+            (cmSystemTools::IsOn(disableOptimizations) ? "true" : "false"));
+        }
+      }
+    }
+    if (!shaderObjectFileName.empty()) {
+      e2.Element("ObjectFileOutput", shaderObjectFileName);
     }
     if (!shaderAdditionalFlags.empty()) {
-      this->WriteString("<AdditionalOptions>", 3);
-      (*this->BuildFileStream) << cmVS10EscapeXML(shaderAdditionalFlags)
-                               << "</AdditionalOptions>\n";
+      e2.Element("AdditionalOptions", shaderAdditionalFlags);
     }
     if (!settingsGenerator.empty()) {
-      this->WriteString("<Generator>", 3);
-      (*this->BuildFileStream) << cmVS10EscapeXML(settingsGenerator)
-                               << "</Generator>\n";
+      e2.Element("Generator", settingsGenerator);
     }
     if (!settingsLastGenOutput.empty()) {
-      this->WriteString("<LastGenOutput>", 3);
-      (*this->BuildFileStream) << cmVS10EscapeXML(settingsLastGenOutput)
-                               << "</LastGenOutput>\n";
+      e2.Element("LastGenOutput", settingsLastGenOutput);
     }
     if (!sourceLink.empty()) {
-      this->WriteString("<Link>", 3);
-      (*this->BuildFileStream) << cmVS10EscapeXML(sourceLink) << "</Link>\n";
+      e2.Element("Link", sourceLink);
     }
     if (!subType.empty()) {
-      this->WriteString("<SubType>", 3);
-      (*this->BuildFileStream) << cmVS10EscapeXML(subType) << "</SubType>\n";
+      e2.Element("SubType", subType);
     }
     if (!copyToOutDir.empty()) {
-      this->WriteString("<CopyToOutputDirectory>", 3);
-      (*this->BuildFileStream) << cmVS10EscapeXML(copyToOutDir)
-                               << "</CopyToOutputDirectory>\n";
+      e2.Element("CopyToOutputDirectory", copyToOutDir);
     }
     if (!includeInVsix.empty()) {
-      this->WriteString("<IncludeInVSIX>", 3);
-      (*this->BuildFileStream) << cmVS10EscapeXML(includeInVsix)
-                               << "</IncludeInVSIX>\n";
+      e2.Element("IncludeInVSIX", includeInVsix);
     }
     // write source file specific tags
-    this->WriteCSharpSourceProperties(sourceFileTags);
-    this->WriteString("</", 2);
-    (*this->BuildFileStream) << tool << ">\n";
-  } else {
-    this->WriteSource(tool, sf);
+    this->WriteCSharpSourceProperties(e2, sourceFileTags);
   }
 }
 
-void cmVisualStudio10TargetGenerator::WriteSource(std::string const& tool,
-                                                  cmSourceFile const* sf,
-                                                  const char* end)
+void cmVisualStudio10TargetGenerator::WriteSource(Elem& e2,
+                                                  std::string const& tool,
+                                                  cmSourceFile const* sf)
 {
   // Visual Studio tools append relative paths to the current dir, as in:
   //
@@ -1853,7 +1866,7 @@ void cmVisualStudio10TargetGenerator::WriteSource(std::string const& tool,
   std::string sourceFile = this->ConvertPath(sf->GetFullPath(), forceRelative);
   if (this->LocalGenerator->GetVersion() ==
         cmGlobalVisualStudioGenerator::VS10 &&
-      cmSystemTools::FileIsFullPath(sourceFile.c_str())) {
+      cmSystemTools::FileIsFullPath(sourceFile)) {
     // 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
@@ -1874,21 +1887,20 @@ void cmVisualStudio10TargetGenerator::WriteSource(std::string const& tool,
     }
   }
   ConvertToWindowsSlash(sourceFile);
-  this->WriteString("<", 2);
-  (*this->BuildFileStream) << tool << " Include=\""
-                           << cmVS10EscapeXML(sourceFile) << "\""
-                           << (end ? end : " />\n");
+  e2.StartElement(tool.c_str());
+  e2.Attribute("Include", sourceFile);
 
   ToolSource toolSource = { sf, forceRelative };
   this->Tools[tool].push_back(toolSource);
 }
 
-void cmVisualStudio10TargetGenerator::WriteAllSources()
+void cmVisualStudio10TargetGenerator::WriteAllSources(Elem& e0)
 {
   if (this->GeneratorTarget->GetType() > cmStateEnums::UTILITY) {
     return;
   }
-  this->WriteString("<ItemGroup>\n", 1);
+  Elem e1(e0, "ItemGroup");
+  e1.SetHasElements();
 
   std::vector<size_t> all_configs;
   for (size_t ci = 0; ci < this->Configurations.size(); ++ci) {
@@ -1906,7 +1918,7 @@ void cmVisualStudio10TargetGenerator::WriteAllSources()
       // Skip explicit reference to CMakeLists.txt source.
       continue;
     }
-    std::string tool;
+    const char* tool = nullptr;
     switch (si.Kind) {
       case cmGeneratorTarget::SourceKindAppManifest:
         tool = "AppxManifest";
@@ -1933,10 +1945,10 @@ void cmVisualStudio10TargetGenerator::WriteAllSources()
         }
         break;
       case cmGeneratorTarget::SourceKindExtra:
-        this->WriteExtraSource(si.Source);
+        this->WriteExtraSource(e1, si.Source);
         break;
       case cmGeneratorTarget::SourceKindHeader:
-        this->WriteHeaderSource(si.Source);
+        this->WriteHeaderSource(e1, si.Source);
         break;
       case cmGeneratorTarget::SourceKindIDL:
         tool = "Midl";
@@ -1975,7 +1987,7 @@ void cmVisualStudio10TargetGenerator::WriteAllSources()
         break;
     }
 
-    if (!tool.empty()) {
+    if (tool) {
       // Compute set of configurations to exclude, if any.
       std::vector<size_t> const& include_configs = si.Configs;
       std::vector<size_t> exclude_configs;
@@ -1983,43 +1995,24 @@ void cmVisualStudio10TargetGenerator::WriteAllSources()
                           include_configs.begin(), include_configs.end(),
                           std::back_inserter(exclude_configs));
 
+      Elem e2(e1);
+      this->WriteSource(e2, tool, si.Source);
       if (si.Kind == cmGeneratorTarget::SourceKindObjectSource) {
-        // FIXME: refactor generation to avoid tracking XML syntax state.
-        this->WriteSource(tool, si.Source, "");
-        bool have_nested = this->OutputSourceSpecificFlags(si.Source);
-        if (!exclude_configs.empty()) {
-          if (!have_nested) {
-            (*this->BuildFileStream) << ">\n";
-          }
-          this->WriteExcludeFromBuild(exclude_configs);
-          have_nested = true;
-        }
-        if (have_nested) {
-          this->WriteString("</", 2);
-          (*this->BuildFileStream) << tool << ">\n";
-        } else {
-          (*this->BuildFileStream) << " />\n";
-        }
-      } else if (!exclude_configs.empty()) {
-        this->WriteSource(tool, si.Source, ">\n");
-        this->WriteExcludeFromBuild(exclude_configs);
-        this->WriteString("</", 2);
-        (*this->BuildFileStream) << tool << ">\n";
-      } else {
-        this->WriteSource(tool, si.Source);
+        this->OutputSourceSpecificFlags(e2, si.Source);
+      }
+      if (!exclude_configs.empty()) {
+        this->WriteExcludeFromBuild(e2, exclude_configs);
       }
     }
   }
 
   if (this->IsMissingFiles) {
-    this->WriteMissingFiles();
+    this->WriteMissingFiles(e1);
   }
-
-  this->WriteString("</ItemGroup>\n", 1);
 }
 
-bool cmVisualStudio10TargetGenerator::OutputSourceSpecificFlags(
-  cmSourceFile const* source)
+void cmVisualStudio10TargetGenerator::OutputSourceSpecificFlags(
+  Elem& e2, cmSourceFile const* source)
 {
   cmSourceFile const& sf = *source;
 
@@ -2079,22 +2072,13 @@ bool cmVisualStudio10TargetGenerator::OutputSourceSpecificFlags(
     }
   }
   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;
-    firstString = "";
-    hasFlags = true;
     if (lang == "CUDA") {
-      this->WriteString("<CompileOut>", 3);
-      (*this->BuildFileStream) << "$(IntDir)/" << objectName
-                               << "</CompileOut>\n";
+      e2.Element("CompileOut", "$(IntDir)/" + objectName);
     } else {
-      this->WriteString("<ObjectFileName>", 3);
-      (*this->BuildFileStream) << "$(IntDir)/" << objectName
-                               << "</ObjectFileName>\n";
+      e2.Element("ObjectFileName", "$(IntDir)/" + objectName);
     }
   }
   for (std::string const& config : this->Configurations) {
@@ -2114,11 +2098,7 @@ bool cmVisualStudio10TargetGenerator::OutputSourceSpecificFlags(
     // use them
     if (!flags.empty() || !options.empty() || !configDefines.empty() ||
         !includes.empty() || compileAs || noWinRT) {
-      (*this->BuildFileStream) << firstString;
-      firstString = ""; // only do firstString once
-      hasFlags = true;
-      cmGlobalVisualStudio10Generator* gg =
-        static_cast<cmGlobalVisualStudio10Generator*>(this->GlobalGenerator);
+      cmGlobalVisualStudio10Generator* gg = this->GlobalGenerator;
       cmIDEFlagTable const* flagtable = nullptr;
       const std::string& srclang = source->GetLanguage();
       if (srclang == "C" || srclang == "CXX") {
@@ -2137,9 +2117,9 @@ bool cmVisualStudio10TargetGenerator::OutputSourceSpecificFlags(
       cmGeneratorExpressionInterpreter genexInterpreter(
         this->LocalGenerator, this->GeneratorTarget, config,
         this->GeneratorTarget->GetName(), lang);
-      cmVisualStudioGeneratorOptions clOptions(
+      cmVS10GeneratorOptions clOptions(
         this->LocalGenerator, cmVisualStudioGeneratorOptions::Compiler,
-        flagtable, 0, this);
+        flagtable, this);
       if (compileAs) {
         clOptions.AddFlag("CompileAs", compileAs);
       }
@@ -2170,7 +2150,7 @@ bool cmVisualStudio10TargetGenerator::OutputSourceSpecificFlags(
         clOptions.AddDefines(
           genexInterpreter.Evaluate(configDefines, "COMPILE_DEFINITIONS"));
       } else {
-        clOptions.AddDefines(configDefines.c_str());
+        clOptions.AddDefines(configDefines);
       }
       std::vector<std::string> includeList;
       if (configDependentIncludes) {
@@ -2182,23 +2162,18 @@ bool cmVisualStudio10TargetGenerator::OutputSourceSpecificFlags(
                                                        *source);
       }
       clOptions.AddIncludes(includeList);
-      clOptions.SetConfiguration(config.c_str());
-      clOptions.PrependInheritedString("AdditionalOptions");
-      clOptions.OutputAdditionalIncludeDirectories(*this->BuildFileStream,
-                                                   "      ", "\n", lang);
-      clOptions.OutputFlagMap(*this->BuildFileStream, "      ");
-      clOptions.OutputPreprocessorDefinitions(*this->BuildFileStream, "      ",
-                                              "\n", lang);
+      clOptions.SetConfiguration(config);
+      OptionsHelper oh(clOptions, e2);
+      oh.PrependInheritedString("AdditionalOptions");
+      oh.OutputAdditionalIncludeDirectories(lang);
+      oh.OutputFlagMap();
+      oh.OutputPreprocessorDefinitions(lang);
     }
   }
   if (this->IsXamlSource(source->GetFullPath())) {
-    (*this->BuildFileStream) << firstString;
-    firstString = ""; // only do firstString once
-    hasFlags = true;
-    this->WriteString("<DependentUpon>", 3);
     const std::string& fileName = source->GetFullPath();
     std::string xamlFileName = fileName.substr(0, fileName.find_last_of("."));
-    (*this->BuildFileStream) << xamlFileName << "</DependentUpon>\n";
+    e2.Element("DependentUpon", xamlFileName);
   }
   if (this->ProjectType == csproj) {
     std::string f = source->GetFullPath();
@@ -2213,29 +2188,25 @@ bool cmVisualStudio10TargetGenerator::OutputSourceSpecificFlags(
     this->GetCSharpSourceProperties(&sf, sourceFileTags);
     // write source file specific tags
     if (!sourceFileTags.empty()) {
-      hasFlags = true;
-      (*this->BuildFileStream) << firstString;
-      firstString = "";
-      this->WriteCSharpSourceProperties(sourceFileTags);
+      this->WriteCSharpSourceProperties(e2, sourceFileTags);
     }
   }
-
-  return hasFlags;
 }
 
 void cmVisualStudio10TargetGenerator::WriteExcludeFromBuild(
-  std::vector<size_t> const& exclude_configs)
+  Elem& e2, std::vector<size_t> const& exclude_configs)
 {
   for (size_t ci : exclude_configs) {
-    this->WriteString("", 3);
-    (*this->BuildFileStream)
-      << "<ExcludedFromBuild Condition=\"'$(Configuration)|$(Platform)'=='"
-      << cmVS10EscapeXML(this->Configurations[ci]) << "|"
-      << cmVS10EscapeXML(this->Platform) << "'\">true</ExcludedFromBuild>\n";
+    e2.WritePlatformConfigTag("ExcludedFromBuild",
+                              "'$(Configuration)|$(Platform)'=='" +
+                                this->Configurations[ci] + "|" +
+                                this->Platform + "'",
+                              "true");
   }
 }
 
-void cmVisualStudio10TargetGenerator::WritePathAndIncrementalLinkOptions()
+void cmVisualStudio10TargetGenerator::WritePathAndIncrementalLinkOptions(
+  Elem& e0)
 {
   cmStateEnums::TargetType ttype = this->GeneratorTarget->GetType();
   if (ttype > cmStateEnums::GLOBAL_TARGET) {
@@ -2245,16 +2216,13 @@ void cmVisualStudio10TargetGenerator::WritePathAndIncrementalLinkOptions()
     return;
   }
 
-  this->WriteString("<PropertyGroup>\n", 1);
-  this->WriteString("<_ProjectFileVersion>10.0.20506.1"
-                    "</_ProjectFileVersion>\n",
-                    2);
+  Elem e1(e0, "PropertyGroup");
+  e1.Element("_ProjectFileVersion", "10.0.20506.1");
   for (std::string const& config : this->Configurations) {
+    const std::string cond = this->CalcCondition(config);
     if (ttype >= cmStateEnums::UTILITY) {
-      this->WritePlatformConfigTag("IntDir", config, 2);
-      *this->BuildFileStream
-        << "$(Platform)\\$(Configuration)\\$(ProjectName)\\"
-        << "</IntDir>\n";
+      e1.WritePlatformConfigTag(
+        "IntDir", cond, "$(Platform)\\$(Configuration)\\$(ProjectName)\\");
     } else {
       std::string intermediateDir =
         this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
@@ -2274,25 +2242,63 @@ void cmVisualStudio10TargetGenerator::WritePathAndIncrementalLinkOptions()
       ConvertToWindowsSlash(intermediateDir);
       ConvertToWindowsSlash(outDir);
 
-      this->WritePlatformConfigTag("OutDir", config, 2);
-      *this->BuildFileStream << cmVS10EscapeXML(outDir) << "</OutDir>\n";
+      e1.WritePlatformConfigTag("OutDir", cond, outDir);
+
+      e1.WritePlatformConfigTag("IntDir", cond, intermediateDir);
+
+      if (const char* sdkExecutableDirectories = this->Makefile->GetDefinition(
+            "CMAKE_VS_SDK_EXECUTABLE_DIRECTORIES")) {
+        e1.WritePlatformConfigTag("ExecutablePath", cond,
+                                  sdkExecutableDirectories);
+      }
+
+      if (const char* sdkIncludeDirectories = this->Makefile->GetDefinition(
+            "CMAKE_VS_SDK_INCLUDE_DIRECTORIES")) {
+        e1.WritePlatformConfigTag("IncludePath", cond, sdkIncludeDirectories);
+      }
+
+      if (const char* sdkReferenceDirectories = this->Makefile->GetDefinition(
+            "CMAKE_VS_SDK_REFERENCE_DIRECTORIES")) {
+        e1.WritePlatformConfigTag("ReferencePath", cond,
+                                  sdkReferenceDirectories);
+      }
+
+      if (const char* sdkLibraryDirectories = this->Makefile->GetDefinition(
+            "CMAKE_VS_SDK_LIBRARY_DIRECTORIES")) {
+        e1.WritePlatformConfigTag("LibraryPath", cond, sdkLibraryDirectories);
+      }
 
-      this->WritePlatformConfigTag("IntDir", config, 2);
-      *this->BuildFileStream << cmVS10EscapeXML(intermediateDir)
-                             << "</IntDir>\n";
+      if (const char* sdkLibraryWDirectories = this->Makefile->GetDefinition(
+            "CMAKE_VS_SDK_LIBRARY_WINRT_DIRECTORIES")) {
+        e1.WritePlatformConfigTag("LibraryWPath", cond,
+                                  sdkLibraryWDirectories);
+      }
+
+      if (const char* sdkSourceDirectories =
+            this->Makefile->GetDefinition("CMAKE_VS_SDK_SOURCE_DIRECTORIES")) {
+        e1.WritePlatformConfigTag("SourcePath", cond, sdkSourceDirectories);
+      }
+
+      if (const char* sdkExcludeDirectories = this->Makefile->GetDefinition(
+            "CMAKE_VS_SDK_EXCLUDE_DIRECTORIES")) {
+        e1.WritePlatformConfigTag("ExcludePath", cond, sdkExcludeDirectories);
+      }
 
       if (const char* workingDir = this->GeneratorTarget->GetProperty(
             "VS_DEBUGGER_WORKING_DIRECTORY")) {
-        this->WritePlatformConfigTag("LocalDebuggerWorkingDirectory", config,
-                                     2);
-        *this->BuildFileStream << cmVS10EscapeXML(workingDir)
-                               << "</LocalDebuggerWorkingDirectory>\n";
+        e1.WritePlatformConfigTag("LocalDebuggerWorkingDirectory", cond,
+                                  workingDir);
+      }
+
+      if (const char* debuggerCommand =
+            this->GeneratorTarget->GetProperty("VS_DEBUGGER_COMMAND")) {
+        e1.WritePlatformConfigTag("LocalDebuggerCommand", cond,
+                                  debuggerCommand);
       }
 
       std::string name =
         cmSystemTools::GetFilenameWithoutLastExtension(targetNameFull);
-      this->WritePlatformConfigTag("TargetName", config, 2);
-      *this->BuildFileStream << cmVS10EscapeXML(name) << "</TargetName>\n";
+      e1.WritePlatformConfigTag("TargetName", cond, name);
 
       std::string ext =
         cmSystemTools::GetFilenameLastExtension(targetNameFull);
@@ -2301,17 +2307,15 @@ void cmVisualStudio10TargetGenerator::WritePathAndIncrementalLinkOptions()
         // A single "." appears to be treated as an empty extension.
         ext = ".";
       }
-      this->WritePlatformConfigTag("TargetExt", config, 2);
-      *this->BuildFileStream << cmVS10EscapeXML(ext) << "</TargetExt>\n";
+      e1.WritePlatformConfigTag("TargetExt", cond, ext);
 
-      this->OutputLinkIncremental(config);
+      this->OutputLinkIncremental(e1, config);
     }
   }
-  this->WriteString("</PropertyGroup>\n", 1);
 }
 
 void cmVisualStudio10TargetGenerator::OutputLinkIncremental(
-  std::string const& configName)
+  Elem& e1, std::string const& configName)
 {
   if (!this->MSTools) {
     return;
@@ -2326,17 +2330,16 @@ void cmVisualStudio10TargetGenerator::OutputLinkIncremental(
     return;
   }
   Options& linkOptions = *(this->LinkOptions[configName]);
+  const std::string cond = this->CalcCondition(configName);
 
   const char* incremental = linkOptions.GetFlag("LinkIncremental");
-  this->WritePlatformConfigTag("LinkIncremental", configName, 2);
-  *this->BuildFileStream << (incremental ? incremental : "true")
-                         << "</LinkIncremental>\n";
+  e1.WritePlatformConfigTag("LinkIncremental", cond,
+                            (incremental ? incremental : "true"));
   linkOptions.RemoveFlag("LinkIncremental");
 
   const char* manifest = linkOptions.GetFlag("GenerateManifest");
-  this->WritePlatformConfigTag("GenerateManifest", configName, 2);
-  *this->BuildFileStream << (manifest ? manifest : "true")
-                         << "</GenerateManifest>\n";
+  e1.WritePlatformConfigTag("GenerateManifest", cond,
+                            (manifest ? manifest : "true"));
   linkOptions.RemoveFlag("GenerateManifest");
 
   // Some link options belong here.  Use them now and remove them so that
@@ -2345,8 +2348,7 @@ void cmVisualStudio10TargetGenerator::OutputLinkIncremental(
   for (const char** f = flags; *f; ++f) {
     const char* flag = *f;
     if (const char* value = linkOptions.GetFlag(flag)) {
-      this->WritePlatformConfigTag(flag, configName, 2);
-      *this->BuildFileStream << value << "</" << flag << ">\n";
+      e1.WritePlatformConfigTag(flag, cond, value);
       linkOptions.RemoveFlag(flag);
     }
   }
@@ -2366,8 +2368,8 @@ std::vector<std::string> cmVisualStudio10TargetGenerator::GetIncludes(
 
 bool cmVisualStudio10TargetGenerator::ComputeClOptions()
 {
-  for (std::string const& i : this->Configurations) {
-    if (!this->ComputeClOptions(i)) {
+  for (std::string const& c : this->Configurations) {
+    if (!this->ComputeClOptions(c)) {
       return false;
     }
   }
@@ -2381,8 +2383,7 @@ bool cmVisualStudio10TargetGenerator::ComputeClOptions(
   // copied from cmLocalVisualStudio7Generator.cxx 805
   // TODO: Integrate code below with cmLocalVisualStudio7Generator.
 
-  cmGlobalVisualStudio10Generator* gg =
-    static_cast<cmGlobalVisualStudio10Generator*>(this->GlobalGenerator);
+  cmGlobalVisualStudio10Generator* gg = this->GlobalGenerator;
   std::unique_ptr<Options> pOptions;
   switch (this->ProjectType) {
     case vcxproj:
@@ -2429,15 +2430,11 @@ bool cmVisualStudio10TargetGenerator::ComputeClOptions(
     std::string baseFlagVar = "CMAKE_";
     baseFlagVar += langForClCompile;
     baseFlagVar += "_FLAGS";
-    flags =
-      this->GeneratorTarget->Target->GetMakefile()->GetRequiredDefinition(
-        baseFlagVar);
+    flags = this->Makefile->GetRequiredDefinition(baseFlagVar);
     std::string flagVar =
       baseFlagVar + std::string("_") + cmSystemTools::UpperCase(configName);
     flags += " ";
-    flags +=
-      this->GeneratorTarget->Target->GetMakefile()->GetRequiredDefinition(
-        flagVar);
+    flags += this->Makefile->GetRequiredDefinition(flagVar);
     this->LocalGenerator->AddCompileOptions(flags, this->GeneratorTarget,
                                             langForClCompile, configName);
   }
@@ -2453,8 +2450,7 @@ bool cmVisualStudio10TargetGenerator::ComputeClOptions(
   this->GeneratorTarget->IsIPOEnabled(linkLanguage, configName);
 
   // Get preprocessor definitions for this directory.
-  std::string defineFlags =
-    this->GeneratorTarget->Target->GetMakefile()->GetDefineFlags();
+  std::string defineFlags = this->Makefile->GetDefineFlags();
   if (this->MSTools) {
     if (this->ProjectType == vcxproj) {
       clOptions.FixExceptionHandlingDefault();
@@ -2463,6 +2459,34 @@ bool cmVisualStudio10TargetGenerator::ComputeClOptions(
       clOptions.AddFlag("AssemblerListingLocation", asmLocation);
     }
   }
+
+  // check for managed C++ assembly compiler flag. This overrides any
+  // /clr* compiler flags which may be defined in the flags variable(s).
+  if (this->ProjectType != csproj) {
+    // Warn if /clr was added manually. This should not be done
+    // anymore, because cmGeneratorTarget may not be aware that the
+    // target uses C++/CLI.
+    if (flags.find("/clr") != std::string::npos ||
+        defineFlags.find("/clr") != std::string::npos) {
+      if (configName == this->Configurations[0]) {
+        std::string message = "For the target \"" +
+          this->GeneratorTarget->GetName() +
+          "\" the /clr compiler flag was added manually. " +
+          "Set usage of C++/CLI by setting COMMON_LANGUAGE_RUNTIME "
+          "target property.";
+        this->Makefile->IssueMessage(cmake::MessageType::WARNING, message);
+      }
+    }
+    if (auto* clr =
+          this->GeneratorTarget->GetProperty("COMMON_LANGUAGE_RUNTIME")) {
+      std::string clrString = clr;
+      if (!clrString.empty()) {
+        clrString = ":" + clrString;
+      }
+      flags += " /clr" + clrString;
+    }
+  }
+
   clOptions.Parse(flags.c_str());
   clOptions.Parse(defineFlags.c_str());
   std::vector<std::string> targetDefines;
@@ -2525,10 +2549,15 @@ bool cmVisualStudio10TargetGenerator::ComputeClOptions(
   if (this->ProjectType != csproj && clOptions.IsManaged()) {
     this->Managed = true;
     std::string managedType = clOptions.GetFlag("CompileAsManaged");
-    if (managedType == "Safe") {
+    if (managedType == "Safe" || managedType == "Pure") {
       // force empty calling convention if safe clr is used
       clOptions.AddFlag("CallingConvention", "");
     }
+    // The default values of these flags are incompatible to
+    // managed assemblies. We have to force valid values if
+    // the target is a managed C++ target.
+    clOptions.AddFlag("ExceptionHandling", "Async");
+    clOptions.AddFlag("BasicRuntimeChecks", "Default");
   }
   if (this->ProjectType == csproj) {
     // /nowin32manifest overrides /win32manifest: parameter
@@ -2542,26 +2571,23 @@ bool cmVisualStudio10TargetGenerator::ComputeClOptions(
 }
 
 void cmVisualStudio10TargetGenerator::WriteClOptions(
-  std::string const& configName)
+  Elem& e1, std::string const& configName)
 {
   Options& clOptions = *(this->ClOptions[configName]);
   if (this->ProjectType == csproj) {
     return;
   }
-  this->WriteString("<ClCompile>\n", 2);
-  clOptions.PrependInheritedString("AdditionalOptions");
-  clOptions.OutputAdditionalIncludeDirectories(
-    *this->BuildFileStream, "      ", "\n", this->LangForClCompile);
-  clOptions.OutputFlagMap(*this->BuildFileStream, "      ");
-  clOptions.OutputPreprocessorDefinitions(*this->BuildFileStream, "      ",
-                                          "\n", this->LangForClCompile);
+  Elem e2(e1, "ClCompile");
+  OptionsHelper oh(clOptions, e2);
+  oh.PrependInheritedString("AdditionalOptions");
+  oh.OutputAdditionalIncludeDirectories(this->LangForClCompile);
+  oh.OutputFlagMap();
+  oh.OutputPreprocessorDefinitions(this->LangForClCompile);
 
   if (this->NsightTegra) {
     if (const char* processMax =
           this->GeneratorTarget->GetProperty("ANDROID_PROCESS_MAX")) {
-      this->WriteString("<ProcessMax>", 3);
-      *this->BuildFileStream << cmVS10EscapeXML(processMax)
-                             << "</ProcessMax>\n";
+      e2.Element("ProcessMax", processMax);
     }
   }
 
@@ -2569,12 +2595,9 @@ void cmVisualStudio10TargetGenerator::WriteClOptions(
     cmsys::RegularExpression clangToolset("v[0-9]+_clang_.*");
     const char* toolset = this->GlobalGenerator->GetPlatformToolset();
     if (toolset && clangToolset.find(toolset)) {
-      this->WriteString("<ObjectFileName>"
-                        "$(IntDir)%(filename).obj"
-                        "</ObjectFileName>\n",
-                        3);
+      e2.Element("ObjectFileName", "$(IntDir)%(filename).obj");
     } else {
-      this->WriteString("<ObjectFileName>$(IntDir)</ObjectFileName>\n", 3);
+      e2.Element("ObjectFileName", "$(IntDir)");
     }
 
     // If not in debug mode, write the DebugInformationFormat field
@@ -2582,27 +2605,35 @@ void cmVisualStudio10TargetGenerator::WriteClOptions(
     // goes on its own line because Visual Studio corrects it this
     // way when saving the project after CMake generates it.
     if (!clOptions.IsDebug()) {
-      this->WriteString("<DebugInformationFormat>\n", 3);
-      this->WriteString("</DebugInformationFormat>\n", 3);
+      Elem e3(e2, "DebugInformationFormat");
+      e3.SetHasElements();
     }
 
     // Specify the compiler program database file if configured.
     std::string pdb = this->GeneratorTarget->GetCompilePDBPath(configName);
     if (!pdb.empty()) {
       ConvertToWindowsSlash(pdb);
-      this->WriteString("<ProgramDataBaseFileName>", 3);
-      *this->BuildFileStream << cmVS10EscapeXML(pdb)
-                             << "</ProgramDataBaseFileName>\n";
+      e2.Element("ProgramDataBaseFileName", pdb);
     }
-  }
 
-  this->WriteString("</ClCompile>\n", 2);
+    // add AdditionalUsingDirectories
+    if (this->AdditionalUsingDirectories.count(configName) > 0) {
+      std::string dirs;
+      for (auto u : this->AdditionalUsingDirectories[configName]) {
+        if (!dirs.empty()) {
+          dirs.append(";");
+        }
+        dirs.append(u);
+      }
+      e2.Element("AdditionalUsingDirectories", dirs);
+    }
+  }
 }
 
 bool cmVisualStudio10TargetGenerator::ComputeRcOptions()
 {
-  for (std::string const& i : this->Configurations) {
-    if (!this->ComputeRcOptions(i)) {
+  for (std::string const& c : this->Configurations) {
+    if (!this->ComputeRcOptions(c)) {
       return false;
     }
   }
@@ -2612,8 +2643,7 @@ bool cmVisualStudio10TargetGenerator::ComputeRcOptions()
 bool cmVisualStudio10TargetGenerator::ComputeRcOptions(
   std::string const& configName)
 {
-  cmGlobalVisualStudio10Generator* gg =
-    static_cast<cmGlobalVisualStudio10Generator*>(this->GlobalGenerator);
+  cmGlobalVisualStudio10Generator* gg = this->GlobalGenerator;
   auto pOptions = cm::make_unique<Options>(
     this->LocalGenerator, Options::ResourceCompiler, gg->GetRcFlagTable());
   Options& rcOptions = *pOptions;
@@ -2639,22 +2669,18 @@ bool cmVisualStudio10TargetGenerator::ComputeRcOptions(
 }
 
 void cmVisualStudio10TargetGenerator::WriteRCOptions(
-  std::string const& configName)
+  Elem& e1, std::string const& configName)
 {
   if (!this->MSTools) {
     return;
   }
-  this->WriteString("<ResourceCompile>\n", 2);
+  Elem e2(e1, "ResourceCompile");
 
-  Options& rcOptions = *(this->RcOptions[configName]);
-  rcOptions.OutputPreprocessorDefinitions(*this->BuildFileStream, "      ",
-                                          "\n", "RC");
-  rcOptions.OutputAdditionalIncludeDirectories(*this->BuildFileStream,
-                                               "      ", "\n", "RC");
+  OptionsHelper rcOptions(*(this->RcOptions[configName]), e2);
+  rcOptions.OutputPreprocessorDefinitions("RC");
+  rcOptions.OutputAdditionalIncludeDirectories("RC");
   rcOptions.PrependInheritedString("AdditionalOptions");
-  rcOptions.OutputFlagMap(*this->BuildFileStream, "      ");
-
-  this->WriteString("</ResourceCompile>\n", 2);
+  rcOptions.OutputFlagMap();
 }
 
 bool cmVisualStudio10TargetGenerator::ComputeCudaOptions()
@@ -2662,8 +2688,8 @@ bool cmVisualStudio10TargetGenerator::ComputeCudaOptions()
   if (!this->GlobalGenerator->IsCudaEnabled()) {
     return true;
   }
-  for (std::string const& i : this->Configurations) {
-    if (!this->ComputeCudaOptions(i)) {
+  for (std::string const& c : this->Configurations) {
+    if (!this->ComputeCudaOptions(c)) {
       return false;
     }
   }
@@ -2673,8 +2699,7 @@ bool cmVisualStudio10TargetGenerator::ComputeCudaOptions()
 bool cmVisualStudio10TargetGenerator::ComputeCudaOptions(
   std::string const& configName)
 {
-  cmGlobalVisualStudio10Generator* gg =
-    static_cast<cmGlobalVisualStudio10Generator*>(this->GlobalGenerator);
+  cmGlobalVisualStudio10Generator* gg = this->GlobalGenerator;
   auto pOptions = cm::make_unique<Options>(
     this->LocalGenerator, Options::CudaCompiler, gg->GetCudaFlagTable());
   Options& cudaOptions = *pOptions;
@@ -2690,8 +2715,7 @@ bool cmVisualStudio10TargetGenerator::ComputeCudaOptions(
                                           configName);
 
   // Get preprocessor definitions for this directory.
-  std::string defineFlags =
-    this->GeneratorTarget->Target->GetMakefile()->GetDefineFlags();
+  std::string defineFlags = this->Makefile->GetDefineFlags();
 
   cudaOptions.Parse(flags.c_str());
   cudaOptions.Parse(defineFlags.c_str());
@@ -2729,6 +2753,20 @@ bool cmVisualStudio10TargetGenerator::ComputeCudaOptions(
     cudaOptions.AppendFlagString("AdditionalOptions", "-x cu");
   }
 
+  // Specify the compiler program database file if configured.
+  std::string pdb = this->GeneratorTarget->GetCompilePDBPath(configName);
+  if (!pdb.empty()) {
+    // CUDA does not have a field for this and does not honor the
+    // ProgramDataBaseFileName field in ClCompile.  Work around this
+    // limitation by creating the directory and passing the flag ourselves.
+    std::string const pdbDir = cmSystemTools::GetFilenamePath(pdb);
+    cmSystemTools::MakeDirectory(pdbDir);
+    pdb = this->ConvertPath(pdb, true);
+    ConvertToWindowsSlash(pdb);
+    std::string const clFd = "-Xcompiler=\"-Fd\\\"" + pdb + "\\\"\"";
+    cudaOptions.AppendFlagString("AdditionalOptions", clFd);
+  }
+
   // CUDA automatically passes the proper '--machine' flag to nvcc
   // for the current architecture, but does not reflect this default
   // in the user-visible IDE settings.  Set it explicitly.
@@ -2771,28 +2809,25 @@ bool cmVisualStudio10TargetGenerator::ComputeCudaOptions(
 
   // Get includes for this target
   cudaOptions.AddIncludes(this->GetIncludes(configName, "CUDA"));
+  cudaOptions.AddFlag("UseHostInclude", "false");
 
   this->CudaOptions[configName] = std::move(pOptions);
   return true;
 }
 
 void cmVisualStudio10TargetGenerator::WriteCudaOptions(
-  std::string const& configName)
+  Elem& e1, std::string const& configName)
 {
   if (!this->MSTools || !this->GlobalGenerator->IsCudaEnabled()) {
     return;
   }
-  this->WriteString("<CudaCompile>\n", 2);
+  Elem e2(e1, "CudaCompile");
 
-  Options& cudaOptions = *(this->CudaOptions[configName]);
-  cudaOptions.OutputAdditionalIncludeDirectories(*this->BuildFileStream,
-                                                 "      ", "\n", "CUDA");
-  cudaOptions.OutputPreprocessorDefinitions(*this->BuildFileStream, "      ",
-                                            "\n", "CUDA");
+  OptionsHelper cudaOptions(*(this->CudaOptions[configName]), e2);
+  cudaOptions.OutputAdditionalIncludeDirectories("CUDA");
+  cudaOptions.OutputPreprocessorDefinitions("CUDA");
   cudaOptions.PrependInheritedString("AdditionalOptions");
-  cudaOptions.OutputFlagMap(*this->BuildFileStream, "      ");
-
-  this->WriteString("</CudaCompile>\n", 2);
+  cudaOptions.OutputFlagMap();
 }
 
 bool cmVisualStudio10TargetGenerator::ComputeCudaLinkOptions()
@@ -2800,8 +2835,8 @@ bool cmVisualStudio10TargetGenerator::ComputeCudaLinkOptions()
   if (!this->GlobalGenerator->IsCudaEnabled()) {
     return true;
   }
-  for (std::string const& i : this->Configurations) {
-    if (!this->ComputeCudaLinkOptions(i)) {
+  for (std::string const& c : this->Configurations) {
+    if (!this->ComputeCudaLinkOptions(c)) {
       return false;
     }
   }
@@ -2811,8 +2846,7 @@ bool cmVisualStudio10TargetGenerator::ComputeCudaLinkOptions()
 bool cmVisualStudio10TargetGenerator::ComputeCudaLinkOptions(
   std::string const& configName)
 {
-  cmGlobalVisualStudio10Generator* gg =
-    static_cast<cmGlobalVisualStudio10Generator*>(this->GlobalGenerator);
+  cmGlobalVisualStudio10Generator* gg = this->GlobalGenerator;
   auto pOptions = cm::make_unique<Options>(
     this->LocalGenerator, Options::CudaCompiler, gg->GetCudaFlagTable());
   Options& cudaLinkOptions = *pOptions;
@@ -2848,7 +2882,7 @@ bool cmVisualStudio10TargetGenerator::ComputeCudaLinkOptions(
 }
 
 void cmVisualStudio10TargetGenerator::WriteCudaLinkOptions(
-  std::string const& configName)
+  Elem& e1, std::string const& configName)
 {
   if (this->GeneratorTarget->GetType() > cmStateEnums::MODULE_LIBRARY) {
     return;
@@ -2858,10 +2892,9 @@ void cmVisualStudio10TargetGenerator::WriteCudaLinkOptions(
     return;
   }
 
-  this->WriteString("<CudaLink>\n", 2);
-  Options& cudaLinkOptions = *(this->CudaLinkOptions[configName]);
-  cudaLinkOptions.OutputFlagMap(*this->BuildFileStream, "      ");
-  this->WriteString("</CudaLink>\n", 2);
+  Elem e2(e1, "CudaLink");
+  OptionsHelper cudaLinkOptions(*(this->CudaLinkOptions[configName]), e2);
+  cudaLinkOptions.OutputFlagMap();
 }
 
 bool cmVisualStudio10TargetGenerator::ComputeMasmOptions()
@@ -2869,8 +2902,8 @@ bool cmVisualStudio10TargetGenerator::ComputeMasmOptions()
   if (!this->GlobalGenerator->IsMasmEnabled()) {
     return true;
   }
-  for (std::string const& i : this->Configurations) {
-    if (!this->ComputeMasmOptions(i)) {
+  for (std::string const& c : this->Configurations) {
+    if (!this->ComputeMasmOptions(c)) {
       return false;
     }
   }
@@ -2880,8 +2913,7 @@ bool cmVisualStudio10TargetGenerator::ComputeMasmOptions()
 bool cmVisualStudio10TargetGenerator::ComputeMasmOptions(
   std::string const& configName)
 {
-  cmGlobalVisualStudio10Generator* gg =
-    static_cast<cmGlobalVisualStudio10Generator*>(this->GlobalGenerator);
+  cmGlobalVisualStudio10Generator* gg = this->GlobalGenerator;
   auto pOptions = cm::make_unique<Options>(
     this->LocalGenerator, Options::MasmCompiler, gg->GetMasmFlagTable());
   Options& masmOptions = *pOptions;
@@ -2903,25 +2935,21 @@ bool cmVisualStudio10TargetGenerator::ComputeMasmOptions(
 }
 
 void cmVisualStudio10TargetGenerator::WriteMasmOptions(
-  std::string const& configName)
+  Elem& e1, std::string const& configName)
 {
   if (!this->MSTools || !this->GlobalGenerator->IsMasmEnabled()) {
     return;
   }
-  this->WriteString("<MASM>\n", 2);
+  Elem e2(e1, "MASM");
 
   // Preprocessor definitions and includes are shared with clOptions.
-  Options& clOptions = *(this->ClOptions[configName]);
-  clOptions.OutputPreprocessorDefinitions(*this->BuildFileStream, "      ",
-                                          "\n", "ASM_MASM");
+  OptionsHelper clOptions(*(this->ClOptions[configName]), e2);
+  clOptions.OutputPreprocessorDefinitions("ASM_MASM");
 
-  Options& masmOptions = *(this->MasmOptions[configName]);
-  masmOptions.OutputAdditionalIncludeDirectories(*this->BuildFileStream,
-                                                 "      ", "\n", "ASM_MASM");
+  OptionsHelper masmOptions(*(this->MasmOptions[configName]), e2);
+  masmOptions.OutputAdditionalIncludeDirectories("ASM_MASM");
   masmOptions.PrependInheritedString("AdditionalOptions");
-  masmOptions.OutputFlagMap(*this->BuildFileStream, "      ");
-
-  this->WriteString("</MASM>\n", 2);
+  masmOptions.OutputFlagMap();
 }
 
 bool cmVisualStudio10TargetGenerator::ComputeNasmOptions()
@@ -2929,8 +2957,8 @@ bool cmVisualStudio10TargetGenerator::ComputeNasmOptions()
   if (!this->GlobalGenerator->IsNasmEnabled()) {
     return true;
   }
-  for (std::string const& i : this->Configurations) {
-    if (!this->ComputeNasmOptions(i)) {
+  for (std::string const& c : this->Configurations) {
+    if (!this->ComputeNasmOptions(c)) {
       return false;
     }
   }
@@ -2940,8 +2968,7 @@ bool cmVisualStudio10TargetGenerator::ComputeNasmOptions()
 bool cmVisualStudio10TargetGenerator::ComputeNasmOptions(
   std::string const& configName)
 {
-  cmGlobalVisualStudio10Generator* gg =
-    static_cast<cmGlobalVisualStudio10Generator*>(this->GlobalGenerator);
+  cmGlobalVisualStudio10Generator* gg = this->GlobalGenerator;
   auto pOptions = cm::make_unique<Options>(
     this->LocalGenerator, Options::NasmCompiler, gg->GetNasmFlagTable());
   Options& nasmOptions = *pOptions;
@@ -2950,8 +2977,9 @@ bool cmVisualStudio10TargetGenerator::ComputeNasmOptions(
   std::string configFlagsVar = std::string("CMAKE_ASM_NASM_FLAGS_") + CONFIG;
   std::string flags =
     std::string(this->Makefile->GetSafeDefinition("CMAKE_ASM_NASM_FLAGS")) +
-    std::string(" -f") + std::string(this->Makefile->GetSafeDefinition(
-                           "CMAKE_ASM_NASM_OBJECT_FORMAT")) +
+    std::string(" -f") +
+    std::string(
+      this->Makefile->GetSafeDefinition("CMAKE_ASM_NASM_OBJECT_FORMAT")) +
     std::string(" ") +
     std::string(this->Makefile->GetSafeDefinition(configFlagsVar));
   nasmOptions.Parse(flags.c_str());
@@ -2964,33 +2992,28 @@ bool cmVisualStudio10TargetGenerator::ComputeNasmOptions(
 }
 
 void cmVisualStudio10TargetGenerator::WriteNasmOptions(
-  std::string const& configName)
+  Elem& e1, std::string const& configName)
 {
   if (!this->GlobalGenerator->IsNasmEnabled()) {
     return;
   }
-  this->WriteString("<NASM>\n", 2);
+  Elem e2(e1, "NASM");
 
   std::vector<std::string> includes =
     this->GetIncludes(configName, "ASM_NASM");
-  Options& nasmOptions = *(this->NasmOptions[configName]);
-  nasmOptions.OutputAdditionalIncludeDirectories(*this->BuildFileStream,
-                                                 "      ", "\n", "ASM_NASM");
-  nasmOptions.OutputFlagMap(*this->BuildFileStream, "      ");
+  OptionsHelper nasmOptions(*(this->NasmOptions[configName]), e2);
+  nasmOptions.OutputAdditionalIncludeDirectories("ASM_NASM");
+  nasmOptions.OutputFlagMap();
   nasmOptions.PrependInheritedString("AdditionalOptions");
-  nasmOptions.OutputPreprocessorDefinitions(*this->BuildFileStream, "      ",
-                                            "\n", "ASM_NASM");
+  nasmOptions.OutputPreprocessorDefinitions("ASM_NASM");
 
   // Preprocessor definitions and includes are shared with clOptions.
-  Options& clOptions = *(this->ClOptions[configName]);
-  clOptions.OutputPreprocessorDefinitions(*this->BuildFileStream, "      ",
-                                          "\n", "ASM_NASM");
-
-  this->WriteString("</NASM>\n", 2);
+  OptionsHelper clOptions(*(this->ClOptions[configName]), e2);
+  clOptions.OutputPreprocessorDefinitions("ASM_NASM");
 }
 
 void cmVisualStudio10TargetGenerator::WriteLibOptions(
-  std::string const& config)
+  Elem& e1, std::string const& config)
 {
   if (this->GeneratorTarget->GetType() != cmStateEnums::STATIC_LIBRARY &&
       this->GeneratorTarget->GetType() != cmStateEnums::OBJECT_LIBRARY) {
@@ -3000,16 +3023,15 @@ void cmVisualStudio10TargetGenerator::WriteLibOptions(
   this->LocalGenerator->GetStaticLibraryFlags(
     libflags, cmSystemTools::UpperCase(config), this->GeneratorTarget);
   if (!libflags.empty()) {
-    this->WriteString("<Lib>\n", 2);
-    cmGlobalVisualStudio10Generator* gg =
-      static_cast<cmGlobalVisualStudio10Generator*>(this->GlobalGenerator);
-    cmVisualStudioGeneratorOptions libOptions(
-      this->LocalGenerator, cmVisualStudioGeneratorOptions::Linker,
-      gg->GetLibFlagTable(), 0, this);
+    Elem e2(e1, "Lib");
+    cmGlobalVisualStudio10Generator* gg = this->GlobalGenerator;
+    cmVS10GeneratorOptions libOptions(this->LocalGenerator,
+                                      cmVisualStudioGeneratorOptions::Linker,
+                                      gg->GetLibFlagTable(), this);
     libOptions.Parse(libflags.c_str());
-    libOptions.PrependInheritedString("AdditionalOptions");
-    libOptions.OutputFlagMap(*this->BuildFileStream, "      ");
-    this->WriteString("</Lib>\n", 2);
+    OptionsHelper oh(libOptions, e2);
+    oh.PrependInheritedString("AdditionalOptions");
+    oh.OutputFlagMap();
   }
 
   // We cannot generate metadata for static libraries.  WindowsPhone
@@ -3017,16 +3039,13 @@ void cmVisualStudio10TargetGenerator::WriteLibOptions(
   // Link tool options even for static libraries.
   if (this->GlobalGenerator->TargetsWindowsPhone() ||
       this->GlobalGenerator->TargetsWindowsStore()) {
-    this->WriteString("<Link>\n", 2);
-    this->WriteString("<GenerateWindowsMetadata>false"
-                      "</GenerateWindowsMetadata>\n",
-                      3);
-    this->WriteString("</Link>\n", 2);
+    Elem e2(e1, "Link");
+    e2.Element("GenerateWindowsMetadata", "false");
   }
 }
 
 void cmVisualStudio10TargetGenerator::WriteManifestOptions(
-  std::string const& config)
+  Elem& e1, std::string const& config)
 {
   if (this->GeneratorTarget->GetType() != cmStateEnums::EXECUTABLE &&
       this->GeneratorTarget->GetType() != cmStateEnums::SHARED_LIBRARY &&
@@ -3037,20 +3056,19 @@ void cmVisualStudio10TargetGenerator::WriteManifestOptions(
   std::vector<cmSourceFile const*> manifest_srcs;
   this->GeneratorTarget->GetManifests(manifest_srcs, config);
   if (!manifest_srcs.empty()) {
-    this->WriteString("<Manifest>\n", 2);
-    this->WriteString("<AdditionalManifestFiles>", 3);
+    std::ostringstream oss;
     for (cmSourceFile const* mi : manifest_srcs) {
       std::string m = this->ConvertPath(mi->GetFullPath(), false);
       ConvertToWindowsSlash(m);
-      (*this->BuildFileStream) << m << ";";
+      oss << m << ";";
     }
-    (*this->BuildFileStream) << "</AdditionalManifestFiles>\n";
-    this->WriteString("</Manifest>\n", 2);
+    Elem e2(e1, "Manifest");
+    e2.Element("AdditionalManifestFiles", oss.str());
   }
 }
 
 void cmVisualStudio10TargetGenerator::WriteAntBuildOptions(
-  std::string const& configName)
+  Elem& e1, std::string const& configName)
 {
   // Look through the sources for AndroidManifest.xml and use
   // its location as the root source directory.
@@ -3068,35 +3086,29 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions(
   }
 
   // Tell MSBuild to launch Ant.
+  Elem e2(e1, "AntBuild");
   {
     std::string antBuildPath = rootDir;
-    this->WriteString("<AntBuild>\n", 2);
-    this->WriteString("<AntBuildPath>", 3);
     ConvertToWindowsSlash(antBuildPath);
-    (*this->BuildFileStream) << cmVS10EscapeXML(antBuildPath)
-                             << "</AntBuildPath>\n";
+    e2.Element("AntBuildPath", antBuildPath);
   }
 
   if (this->GeneratorTarget->GetPropertyAsBool("ANDROID_SKIP_ANT_STEP")) {
-    this->WriteString("<SkipAntStep>true</SkipAntStep>\n", 3);
+    e2.Element("SkipAntStep", "true");
   }
 
   if (this->GeneratorTarget->GetPropertyAsBool("ANDROID_PROGUARD")) {
-    this->WriteString("<EnableProGuard>true</EnableProGuard>\n", 3);
+    e2.Element("EnableProGuard", "true");
   }
 
   if (const char* proGuardConfigLocation =
         this->GeneratorTarget->GetProperty("ANDROID_PROGUARD_CONFIG_PATH")) {
-    this->WriteString("<ProGuardConfigLocation>", 3);
-    (*this->BuildFileStream) << cmVS10EscapeXML(proGuardConfigLocation)
-                             << "</ProGuardConfigLocation>\n";
+    e2.Element("ProGuardConfigLocation", proGuardConfigLocation);
   }
 
   if (const char* securePropertiesLocation =
         this->GeneratorTarget->GetProperty("ANDROID_SECURE_PROPS_PATH")) {
-    this->WriteString("<SecurePropertiesLocation>", 3);
-    (*this->BuildFileStream) << cmVS10EscapeXML(securePropertiesLocation)
-                             << "</SecurePropertiesLocation>\n";
+    e2.Element("SecurePropertiesLocation", securePropertiesLocation);
   }
 
   if (const char* nativeLibDirectoriesExpression =
@@ -3106,9 +3118,7 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions(
       ge.Parse(nativeLibDirectoriesExpression);
     std::string nativeLibDirs =
       cge->Evaluate(this->LocalGenerator, configName);
-    this->WriteString("<NativeLibDirectories>", 3);
-    (*this->BuildFileStream) << cmVS10EscapeXML(nativeLibDirs)
-                             << "</NativeLibDirectories>\n";
+    e2.Element("NativeLibDirectories", nativeLibDirs);
   }
 
   if (const char* nativeLibDependenciesExpression =
@@ -3119,16 +3129,12 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions(
       ge.Parse(nativeLibDependenciesExpression);
     std::string nativeLibDeps =
       cge->Evaluate(this->LocalGenerator, configName);
-    this->WriteString("<NativeLibDependencies>", 3);
-    (*this->BuildFileStream) << cmVS10EscapeXML(nativeLibDeps)
-                             << "</NativeLibDependencies>\n";
+    e2.Element("NativeLibDependencies", nativeLibDeps);
   }
 
   if (const char* javaSourceDir =
         this->GeneratorTarget->GetProperty("ANDROID_JAVA_SOURCE_DIR")) {
-    this->WriteString("<JavaSourceDir>", 3);
-    (*this->BuildFileStream) << cmVS10EscapeXML(javaSourceDir)
-                             << "</JavaSourceDir>\n";
+    e2.Element("JavaSourceDir", javaSourceDir);
   }
 
   if (const char* jarDirectoriesExpression =
@@ -3138,41 +3144,30 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions(
       ge.Parse(jarDirectoriesExpression);
     std::string jarDirectories =
       cge->Evaluate(this->LocalGenerator, configName);
-    this->WriteString("<JarDirectories>", 3);
-    (*this->BuildFileStream) << cmVS10EscapeXML(jarDirectories)
-                             << "</JarDirectories>\n";
+    e2.Element("JarDirectories", jarDirectories);
   }
 
   if (const char* jarDeps =
         this->GeneratorTarget->GetProperty("ANDROID_JAR_DEPENDENCIES")) {
-    this->WriteString("<JarDependencies>", 3);
-    (*this->BuildFileStream) << cmVS10EscapeXML(jarDeps)
-                             << "</JarDependencies>\n";
+    e2.Element("JarDependencies", jarDeps);
   }
 
   if (const char* assetsDirectories =
         this->GeneratorTarget->GetProperty("ANDROID_ASSETS_DIRECTORIES")) {
-    this->WriteString("<AssetsDirectories>", 3);
-    (*this->BuildFileStream) << cmVS10EscapeXML(assetsDirectories)
-                             << "</AssetsDirectories>\n";
+    e2.Element("AssetsDirectories", assetsDirectories);
   }
 
   {
     std::string manifest_xml = rootDir + "/AndroidManifest.xml";
     ConvertToWindowsSlash(manifest_xml);
-    this->WriteString("<AndroidManifestLocation>", 3);
-    (*this->BuildFileStream) << cmVS10EscapeXML(manifest_xml)
-                             << "</AndroidManifestLocation>\n";
+    e2.Element("AndroidManifestLocation", manifest_xml);
   }
 
   if (const char* antAdditionalOptions =
         this->GeneratorTarget->GetProperty("ANDROID_ANT_ADDITIONAL_OPTIONS")) {
-    this->WriteString("<AdditionalOptions>", 3);
-    (*this->BuildFileStream) << cmVS10EscapeXML(antAdditionalOptions)
-                             << " %(AdditionalOptions)</AdditionalOptions>\n";
+    e2.Element("AdditionalOptions",
+               std::string(antAdditionalOptions) + " %(AdditionalOptions)");
   }
-
-  this->WriteString("</AntBuild>\n", 2);
 }
 
 bool cmVisualStudio10TargetGenerator::ComputeLinkOptions()
@@ -3180,8 +3175,8 @@ bool cmVisualStudio10TargetGenerator::ComputeLinkOptions()
   if (this->GeneratorTarget->GetType() == cmStateEnums::EXECUTABLE ||
       this->GeneratorTarget->GetType() == cmStateEnums::SHARED_LIBRARY ||
       this->GeneratorTarget->GetType() == cmStateEnums::MODULE_LIBRARY) {
-    for (std::string const& i : this->Configurations) {
-      if (!this->ComputeLinkOptions(i)) {
+    for (std::string const& c : this->Configurations) {
+      if (!this->ComputeLinkOptions(c)) {
         return false;
       }
     }
@@ -3192,11 +3187,9 @@ bool cmVisualStudio10TargetGenerator::ComputeLinkOptions()
 bool cmVisualStudio10TargetGenerator::ComputeLinkOptions(
   std::string const& config)
 {
-  cmGlobalVisualStudio10Generator* gg =
-    static_cast<cmGlobalVisualStudio10Generator*>(this->GlobalGenerator);
-  auto pOptions =
-    cm::make_unique<Options>(this->LocalGenerator, Options::Linker,
-                             gg->GetLinkFlagTable(), nullptr, this);
+  cmGlobalVisualStudio10Generator* gg = this->GlobalGenerator;
+  auto pOptions = cm::make_unique<Options>(
+    this->LocalGenerator, Options::Linker, gg->GetLinkFlagTable(), this);
   Options& linkOptions = *pOptions;
 
   cmGeneratorTarget::LinkClosure const* linkClosure =
@@ -3224,12 +3217,10 @@ bool cmVisualStudio10TargetGenerator::ComputeLinkOptions(
   linkFlagVarBase += linkType;
   linkFlagVarBase += "_LINKER_FLAGS";
   flags += " ";
-  flags += this->GeneratorTarget->Target->GetMakefile()->GetRequiredDefinition(
-    linkFlagVarBase);
+  flags += this->Makefile->GetRequiredDefinition(linkFlagVarBase);
   std::string linkFlagVar = linkFlagVarBase + "_" + CONFIG;
   flags += " ";
-  flags += this->GeneratorTarget->Target->GetMakefile()->GetRequiredDefinition(
-    linkFlagVar);
+  flags += this->Makefile->GetRequiredDefinition(linkFlagVar);
   const char* targetLinkFlags =
     this->GeneratorTarget->GetProperty("LINK_FLAGS");
   if (targetLinkFlags) {
@@ -3256,14 +3247,16 @@ bool cmVisualStudio10TargetGenerator::ComputeLinkOptions(
 
   std::vector<std::string> libVec;
   std::vector<std::string> vsTargetVec;
-  this->AddLibraries(cli, libVec, vsTargetVec);
+  this->AddLibraries(cli, libVec, vsTargetVec, config);
   if (std::find(linkClosure->Languages.begin(), linkClosure->Languages.end(),
                 "CUDA") != linkClosure->Languages.end()) {
     switch (this->CudaOptions[config]->GetCudaRuntime()) {
       case cmVisualStudioGeneratorOptions::CudaRuntimeStatic:
+        libVec.push_back("cudadevrt.lib");
         libVec.push_back("cudart_static.lib");
         break;
       case cmVisualStudioGeneratorOptions::CudaRuntimeShared:
+        libVec.push_back("cudadevrt.lib");
         libVec.push_back("cudart.lib");
         break;
       case cmVisualStudioGeneratorOptions::CudaRuntimeNone:
@@ -3383,7 +3376,7 @@ bool cmVisualStudio10TargetGenerator::ComputeLinkOptions(
     cmGeneratorTarget::ModuleDefinitionInfo const* mdi =
       this->GeneratorTarget->GetModuleDefinitionInfo(config);
     if (mdi && !mdi->DefFile.empty()) {
-      linkOptions.AddFlag("ModuleDefinitionFile", mdi->DefFile.c_str());
+      linkOptions.AddFlag("ModuleDefinitionFile", mdi->DefFile);
     }
     linkOptions.AppendFlag("IgnoreSpecificDefaultLibraries",
                            "%(IgnoreSpecificDefaultLibraries)");
@@ -3401,6 +3394,15 @@ bool cmVisualStudio10TargetGenerator::ComputeLinkOptions(
     }
   }
 
+  // Managed code cannot be linked with /DEBUG:FASTLINK
+  if (this->Managed) {
+    if (const char* debug = linkOptions.GetFlag("GenerateDebugInformation")) {
+      if (strcmp(debug, "DebugFastLink") == 0) {
+        linkOptions.AddFlag("GenerateDebugInformation", "Debug");
+      }
+    }
+  }
+
   this->LinkOptions[config] = std::move(pOptions);
   return true;
 }
@@ -3408,8 +3410,8 @@ bool cmVisualStudio10TargetGenerator::ComputeLinkOptions(
 bool cmVisualStudio10TargetGenerator::ComputeLibOptions()
 {
   if (this->GeneratorTarget->GetType() == cmStateEnums::STATIC_LIBRARY) {
-    for (std::string const& i : this->Configurations) {
-      if (!this->ComputeLibOptions(i)) {
+    for (std::string const& c : this->Configurations) {
+      if (!this->ComputeLibOptions(c)) {
         return false;
       }
     }
@@ -3447,7 +3449,7 @@ bool cmVisualStudio10TargetGenerator::ComputeLibOptions(
 }
 
 void cmVisualStudio10TargetGenerator::WriteLinkOptions(
-  std::string const& config)
+  Elem& e1, std::string const& config)
 {
   if (this->GeneratorTarget->GetType() == cmStateEnums::STATIC_LIBRARY ||
       this->GeneratorTarget->GetType() > cmStateEnums::MODULE_LIBRARY) {
@@ -3456,31 +3458,69 @@ void cmVisualStudio10TargetGenerator::WriteLinkOptions(
   if (this->ProjectType == csproj) {
     return;
   }
-  Options& linkOptions = *(this->LinkOptions[config]);
-  this->WriteString("<Link>\n", 2);
 
-  linkOptions.PrependInheritedString("AdditionalOptions");
-  linkOptions.OutputFlagMap(*this->BuildFileStream, "      ");
+  {
+    Elem e2(e1, "Link");
+    OptionsHelper linkOptions(*(this->LinkOptions[config]), e2);
+    linkOptions.PrependInheritedString("AdditionalOptions");
+    linkOptions.OutputFlagMap();
+  }
 
-  this->WriteString("</Link>\n", 2);
   if (!this->GlobalGenerator->NeedLinkLibraryDependencies(
         this->GeneratorTarget)) {
-    this->WriteString("<ProjectReference>\n", 2);
-    this->WriteString(
-      "<LinkLibraryDependencies>false</LinkLibraryDependencies>\n", 3);
-    this->WriteString("</ProjectReference>\n", 2);
+    Elem e2(e1, "ProjectReference");
+    e2.Element("LinkLibraryDependencies", "false");
   }
 }
 
 void cmVisualStudio10TargetGenerator::AddLibraries(
-  cmComputeLinkInformation& cli, std::vector<std::string>& libVec,
-  std::vector<std::string>& vsTargetVec)
+  const cmComputeLinkInformation& cli, std::vector<std::string>& libVec,
+  std::vector<std::string>& vsTargetVec, const std::string& config)
 {
   typedef cmComputeLinkInformation::ItemVector ItemVector;
   ItemVector const& libs = cli.GetItems();
   std::string currentBinDir =
     this->LocalGenerator->GetCurrentBinaryDirectory();
   for (cmComputeLinkInformation::Item const& l : libs) {
+    if (l.Target) {
+      auto managedType = l.Target->GetManagedType(config);
+      if (managedType != cmGeneratorTarget::ManagedType::Native &&
+          this->GeneratorTarget->GetManagedType(config) !=
+            cmGeneratorTarget::ManagedType::Native &&
+          l.Target->IsImported()) {
+        auto location = l.Target->GetFullPath(config);
+        if (!location.empty()) {
+          ConvertToWindowsSlash(location);
+          switch (this->ProjectType) {
+            case csproj:
+              // If the target we want to "link" to is an imported managed
+              // target and this is a C# project, we add a hint reference. This
+              // reference is written to project file in
+              // WriteDotNetReferences().
+              this->DotNetHintReferences[config].push_back(
+                DotNetHintReference(l.Target->GetName(), location));
+              break;
+            case vcxproj:
+              // Add path of assembly to list of using-directories, so the
+              // managed assembly can be used by '#using <assembly.dll>' in
+              // code.
+              this->AdditionalUsingDirectories[config].insert(
+                cmSystemTools::GetFilenamePath(location));
+              break;
+          }
+        }
+      }
+      // Do not allow C# targets to be added to the LIB listing. LIB files are
+      // used for linking C++ dependencies. C# libraries do not have lib files.
+      // Instead, they compile down to C# reference libraries (DLL files). The
+      // `<ProjectReference>` elements added to the vcxproj are enough for the
+      // IDE to deduce the DLL file required by other C# projects that need its
+      // reference library.
+      if (managedType == cmGeneratorTarget::ManagedType::Managed) {
+        continue;
+      }
+    }
+
     if (l.IsPath) {
       std::string path =
         this->LocalGenerator->ConvertToRelativePath(currentBinDir, l.Value);
@@ -3516,7 +3556,7 @@ void cmVisualStudio10TargetGenerator::AddTargetsFileAndConfigPair(
 }
 
 void cmVisualStudio10TargetGenerator::WriteMidlOptions(
-  std::string const& configName)
+  Elem& e1, std::string const& configName)
 {
   if (!this->MSTools) {
     return;
@@ -3540,69 +3580,64 @@ void cmVisualStudio10TargetGenerator::WriteMidlOptions(
   // up (for non-directory form, it ends up looking in project binary dir
   // only).  Perhaps there's something to be done to make this more automatic
   // on the CMake side?
-  this->WriteString("<Midl>\n", 2);
-  this->WriteString("<AdditionalIncludeDirectories>", 3);
   std::vector<std::string> const includes =
     this->GetIncludes(configName, "MIDL");
+  std::ostringstream oss;
   for (std::string const& i : includes) {
-    *this->BuildFileStream << cmVS10EscapeXML(i) << ";";
-  }
-  this->WriteString("%(AdditionalIncludeDirectories)"
-                    "</AdditionalIncludeDirectories>\n",
-                    0);
-  this->WriteString("<OutputDirectory>$(ProjectDir)/$(IntDir)"
-                    "</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("</Midl>\n", 2);
+    oss << i << ";";
+  }
+  oss << "%(AdditionalIncludeDirectories)";
+
+  Elem e2(e1, "Midl");
+  e2.Element("AdditionalIncludeDirectories", oss.str());
+  e2.Element("OutputDirectory", "$(ProjectDir)/$(IntDir)");
+  e2.Element("HeaderFileName", "%(Filename).h");
+  e2.Element("TypeLibraryName", "%(Filename).tlb");
+  e2.Element("InterfaceIdentifierFileName", "%(Filename)_i.c");
+  e2.Element("ProxyFileName", "%(Filename)_p.c");
 }
 
-void cmVisualStudio10TargetGenerator::WriteItemDefinitionGroups()
+void cmVisualStudio10TargetGenerator::WriteItemDefinitionGroups(Elem& e0)
 {
   if (this->ProjectType == csproj) {
     return;
   }
-  for (const auto& i : this->Configurations) {
-    this->WritePlatformConfigTag("ItemDefinitionGroup", i, 1);
-    *this->BuildFileStream << "\n";
+  for (const std::string& c : this->Configurations) {
+    Elem e1(e0, "ItemDefinitionGroup");
+    e1.Attribute("Condition", this->CalcCondition(c));
+
     //    output cl compile flags <ClCompile></ClCompile>
     if (this->GeneratorTarget->GetType() <= cmStateEnums::OBJECT_LIBRARY) {
-      this->WriteClOptions(i);
+      this->WriteClOptions(e1, c);
       //    output rc compile flags <ResourceCompile></ResourceCompile>
-      this->WriteRCOptions(i);
-      this->WriteCudaOptions(i);
-      this->WriteMasmOptions(i);
-      this->WriteNasmOptions(i);
+      this->WriteRCOptions(e1, c);
+      this->WriteCudaOptions(e1, c);
+      this->WriteMasmOptions(e1, c);
+      this->WriteNasmOptions(e1, c);
     }
     //    output midl flags       <Midl></Midl>
-    this->WriteMidlOptions(i);
+    this->WriteMidlOptions(e1, c);
     // write events
     if (this->ProjectType != csproj) {
-      this->WriteEvents(i);
+      this->WriteEvents(e1, c);
     }
     //    output link flags       <Link></Link>
-    this->WriteLinkOptions(i);
-    this->WriteCudaLinkOptions(i);
+    this->WriteLinkOptions(e1, c);
+    this->WriteCudaLinkOptions(e1, c);
     //    output lib flags       <Lib></Lib>
-    this->WriteLibOptions(i);
+    this->WriteLibOptions(e1, c);
     //    output manifest flags  <Manifest></Manifest>
-    this->WriteManifestOptions(i);
+    this->WriteManifestOptions(e1, c);
     if (this->NsightTegra &&
         this->GeneratorTarget->GetType() == cmStateEnums::EXECUTABLE &&
         this->GeneratorTarget->GetPropertyAsBool("ANDROID_GUI")) {
-      this->WriteAntBuildOptions(i);
+      this->WriteAntBuildOptions(e1, c);
     }
-    this->WriteString("</ItemDefinitionGroup>\n", 1);
   }
 }
 
 void cmVisualStudio10TargetGenerator::WriteEvents(
-  std::string const& configName)
+  Elem& e1, std::string const& configName)
 {
   bool addedPrelink = false;
   cmGeneratorTarget::ModuleDefinitionInfo const* mdi =
@@ -3613,84 +3648,76 @@ void cmVisualStudio10TargetGenerator::WriteEvents(
       this->GeneratorTarget->GetPreLinkCommands();
     this->GlobalGenerator->AddSymbolExportCommand(this->GeneratorTarget,
                                                   commands, configName);
-    this->WriteEvent("PreLinkEvent", commands, configName);
+    this->WriteEvent(e1, "PreLinkEvent", commands, configName);
   }
   if (!addedPrelink) {
-    this->WriteEvent("PreLinkEvent",
+    this->WriteEvent(e1, "PreLinkEvent",
                      this->GeneratorTarget->GetPreLinkCommands(), configName);
   }
-  this->WriteEvent("PreBuildEvent",
+  this->WriteEvent(e1, "PreBuildEvent",
                    this->GeneratorTarget->GetPreBuildCommands(), configName);
-  this->WriteEvent("PostBuildEvent",
+  this->WriteEvent(e1, "PostBuildEvent",
                    this->GeneratorTarget->GetPostBuildCommands(), configName);
 }
 
 void cmVisualStudio10TargetGenerator::WriteEvent(
-  const char* name, std::vector<cmCustomCommand> const& commands,
+  Elem& e1, const char* name, std::vector<cmCustomCommand> const& commands,
   std::string const& configName)
 {
   if (commands.empty()) {
     return;
   }
-  this->WriteString("<", 2);
-  (*this->BuildFileStream) << name << ">\n";
   cmLocalVisualStudio7Generator* lg = this->LocalGenerator;
   std::string script;
   const char* pre = "";
   std::string comment;
-  for (cmCustomCommand const& i : commands) {
-    cmCustomCommandGenerator ccg(i, configName, this->LocalGenerator);
+  for (cmCustomCommand const& cc : commands) {
+    cmCustomCommandGenerator ccg(cc, configName, lg);
     if (!ccg.HasOnlyEmptyCommandLines()) {
       comment += pre;
       comment += lg->ConstructComment(ccg);
       script += pre;
       pre = "\n";
-      script += cmVS10EscapeXML(lg->ConstructScript(ccg));
+      script += lg->ConstructScript(ccg);
     }
   }
   comment = cmVS10EscapeComment(comment);
   if (this->ProjectType != csproj) {
-    this->WriteString("<Message>", 3);
-    (*this->BuildFileStream) << cmVS10EscapeXML(comment) << "</Message>\n";
-    this->WriteString("<Command>", 3);
+    Elem e2(e1, name);
+    e2.Element("Message", comment);
+    e2.Element("Command", script);
   } else {
     std::string strippedComment = comment;
     strippedComment.erase(
       std::remove(strippedComment.begin(), strippedComment.end(), '\t'),
       strippedComment.end());
+    std::ostringstream oss;
     if (!comment.empty() && !strippedComment.empty()) {
-      (*this->BuildFileStream) << "echo " << cmVS10EscapeXML(comment) << "\n";
+      oss << "echo " << comment << "\n";
     }
+    oss << script << "\n";
+    e1.Element(name, oss.str());
   }
-  (*this->BuildFileStream) << script;
-  if (this->ProjectType != csproj) {
-    (*this->BuildFileStream) << "</Command>";
-  }
-  (*this->BuildFileStream) << "\n";
-  this->WriteString("</", 2);
-  (*this->BuildFileStream) << name << ">\n";
 }
 
-void cmVisualStudio10TargetGenerator::WriteProjectReferences()
+void cmVisualStudio10TargetGenerator::WriteProjectReferences(Elem& e0)
 {
   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 (cmTargetDepend const& i : depends) {
-    cmGeneratorTarget const* dt = i;
+  Elem e1(e0, "ItemGroup");
+  e1.SetHasElements();
+  for (cmGeneratorTarget const* dt : depends) {
     if (dt->GetType() == cmStateEnums::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 (this->GlobalGenerator->TargetIsFortranOnly(dt)) {
       continue;
     }
-    this->WriteString("<ProjectReference Include=\"", 2);
     cmLocalGenerator* lg = dt->GetLocalGenerator();
     std::string name = dt->GetName();
     std::string path;
@@ -3704,27 +3731,41 @@ void cmVisualStudio10TargetGenerator::WriteProjectReferences()
       path += computeProjectFileExtension(dt, *this->Configurations.begin());
     }
     ConvertToWindowsSlash(path);
-    (*this->BuildFileStream) << cmVS10EscapeXML(path) << "\">\n";
-    this->WriteString("<Project>", 3);
-    (*this->BuildFileStream) << "{" << this->GlobalGenerator->GetGUID(name)
-                             << "}";
-    (*this->BuildFileStream) << "</Project>\n";
-    this->WriteString("<Name>", 3);
-    (*this->BuildFileStream) << name << "</Name>\n";
-    this->WriteDotNetReferenceCustomTags(name);
-    if (csproj == this->ProjectType) {
-      if (!static_cast<cmGlobalVisualStudioGenerator*>(this->GlobalGenerator)
-             ->TargetCanBeReferenced(dt)) {
-        this->WriteString(
-          "<ReferenceOutputAssembly>false</ReferenceOutputAssembly>\n", 3);
+    Elem e2(e1, "ProjectReference");
+    e2.Attribute("Include", path);
+    e2.Element("Project", "{" + this->GlobalGenerator->GetGUID(name) + "}");
+    e2.Element("Name", name);
+    this->WriteDotNetReferenceCustomTags(e2, name);
+    if (this->Managed) {
+      // If the dependency target is not managed (compiled with /clr or
+      // C# target) we cannot reference it and have to set
+      // 'ReferenceOutputAssembly' to false.
+      auto referenceNotManaged =
+        dt->GetManagedType("") < cmGeneratorTarget::ManagedType::Mixed;
+      // Workaround to check for manually set /clr flags.
+      if (referenceNotManaged) {
+        if (const auto* flags = dt->GetProperty("COMPILE_OPTIONS")) {
+          std::string flagsStr = flags;
+          if (flagsStr.find("clr") != std::string::npos) {
+            // There is a warning already issued when building the flags.
+            referenceNotManaged = false;
+          }
+        }
+      }
+      // Workaround for static library C# targets
+      if (referenceNotManaged &&
+          dt->GetType() == cmStateEnums::STATIC_LIBRARY) {
+        referenceNotManaged = !dt->HasLanguage("CSharp", "");
+      }
+      if (referenceNotManaged) {
+        e2.Element("ReferenceOutputAssembly", "false");
+        e2.Element("CopyToOutputDirectory", "Never");
       }
     }
-    this->WriteString("</ProjectReference>\n", 2);
   }
-  this->WriteString("</ItemGroup>\n", 1);
 }
 
-void cmVisualStudio10TargetGenerator::WritePlatformExtensions()
+void cmVisualStudio10TargetGenerator::WritePlatformExtensions(Elem& e1)
 {
   // This only applies to Windows 10 apps
   if (this->GlobalGenerator->TargetsWindowsStore() &&
@@ -3732,52 +3773,46 @@ void cmVisualStudio10TargetGenerator::WritePlatformExtensions()
     const char* desktopExtensionsVersion =
       this->GeneratorTarget->GetProperty("VS_DESKTOP_EXTENSIONS_VERSION");
     if (desktopExtensionsVersion) {
-      this->WriteSinglePlatformExtension("WindowsDesktop",
+      this->WriteSinglePlatformExtension(e1, "WindowsDesktop",
                                          desktopExtensionsVersion);
     }
     const char* mobileExtensionsVersion =
       this->GeneratorTarget->GetProperty("VS_MOBILE_EXTENSIONS_VERSION");
     if (mobileExtensionsVersion) {
-      this->WriteSinglePlatformExtension("WindowsMobile",
+      this->WriteSinglePlatformExtension(e1, "WindowsMobile",
                                          mobileExtensionsVersion);
     }
   }
 }
 
 void cmVisualStudio10TargetGenerator::WriteSinglePlatformExtension(
-  std::string const& extension, std::string const& version)
+  Elem& e1, std::string const& extension, std::string const& version)
 {
-  this->WriteString("<Import Project=", 2);
-  (*this->BuildFileStream)
-    << "\"$([Microsoft.Build.Utilities.ToolLocationHelper]"
-    << "::GetPlatformExtensionSDKLocation(`" << extension
-    << ", Version=" << version
-    << "`, $(TargetPlatformIdentifier), $(TargetPlatformVersion), null, "
-    << "$(ExtensionSDKDirectoryRoot), null))"
-    << "\\DesignTime\\CommonConfiguration\\Neutral\\" << extension
-    << ".props\" "
-    << "Condition=\"exists('$("
-    << "[Microsoft.Build.Utilities.ToolLocationHelper]"
-    << "::GetPlatformExtensionSDKLocation(`" << extension
-    << ", Version=" << version
-    << "`, $(TargetPlatformIdentifier), $(TargetPlatformVersion), null, "
-    << "$(ExtensionSDKDirectoryRoot), null))"
-    << "\\DesignTime\\CommonConfiguration\\Neutral\\" << extension
-    << ".props')\" />\n";
+  const std::string s = "$([Microsoft.Build.Utilities.ToolLocationHelper]"
+                        "::GetPlatformExtensionSDKLocation(`" +
+    extension + ", Version=" + version +
+    "`, $(TargetPlatformIdentifier), $(TargetPlatformVersion), null, "
+    "$(ExtensionSDKDirectoryRoot), null))"
+    "\\DesignTime\\CommonConfiguration\\Neutral\\" +
+    extension + ".props";
+
+  Elem e2(e1, "Import");
+  e2.Attribute("Project", s);
+  e2.Attribute("Condition", "exists('" + s + "')");
 }
 
-void cmVisualStudio10TargetGenerator::WriteSDKReferences()
+void cmVisualStudio10TargetGenerator::WriteSDKReferences(Elem& e0)
 {
   std::vector<std::string> sdkReferences;
+  Elem e1(e0);
   bool hasWrittenItemGroup = false;
   if (const char* vsSDKReferences =
         this->GeneratorTarget->GetProperty("VS_SDK_REFERENCES")) {
     cmSystemTools::ExpandListArgument(vsSDKReferences, sdkReferences);
-    this->WriteString("<ItemGroup>\n", 1);
+    e1.StartElement("ItemGroup");
     hasWrittenItemGroup = true;
     for (std::string const& ri : sdkReferences) {
-      this->WriteString("<SDKReference Include=\"", 2);
-      (*this->BuildFileStream) << cmVS10EscapeXML(ri) << "\"/>\n";
+      Elem(e1, "SDKReference").Attribute("Include", ri);
     }
   }
 
@@ -3794,37 +3829,32 @@ void cmVisualStudio10TargetGenerator::WriteSDKReferences()
     if (desktopExtensionsVersion || mobileExtensionsVersion ||
         iotExtensionsVersion) {
       if (!hasWrittenItemGroup) {
-        this->WriteString("<ItemGroup>\n", 1);
-        hasWrittenItemGroup = true;
+        e1.StartElement("ItemGroup");
       }
       if (desktopExtensionsVersion) {
-        this->WriteSingleSDKReference("WindowsDesktop",
+        this->WriteSingleSDKReference(e1, "WindowsDesktop",
                                       desktopExtensionsVersion);
       }
       if (mobileExtensionsVersion) {
-        this->WriteSingleSDKReference("WindowsMobile",
+        this->WriteSingleSDKReference(e1, "WindowsMobile",
                                       mobileExtensionsVersion);
       }
       if (iotExtensionsVersion) {
-        this->WriteSingleSDKReference("WindowsIoT", iotExtensionsVersion);
+        this->WriteSingleSDKReference(e1, "WindowsIoT", iotExtensionsVersion);
       }
     }
   }
-
-  if (hasWrittenItemGroup) {
-    this->WriteString("</ItemGroup>\n", 1);
-  }
 }
 
 void cmVisualStudio10TargetGenerator::WriteSingleSDKReference(
-  std::string const& extension, std::string const& version)
+  Elem& e1, std::string const& extension, std::string const& version)
 {
-  this->WriteString("<SDKReference Include=\"", 2);
-  (*this->BuildFileStream) << extension << ", Version=" << version
-                           << "\" />\n";
+  Elem(e1, "SDKReference")
+    .Attribute("Include", extension + ", Version=" + version);
 }
 
-void cmVisualStudio10TargetGenerator::WriteWinRTPackageCertificateKeyFile()
+void cmVisualStudio10TargetGenerator::WriteWinRTPackageCertificateKeyFile(
+  Elem& e0)
 {
   if ((this->GlobalGenerator->TargetsWindowsStore() ||
        this->GlobalGenerator->TargetsWindowsPhone()) &&
@@ -3845,15 +3875,12 @@ void cmVisualStudio10TargetGenerator::WriteWinRTPackageCertificateKeyFile()
       std::string artifactDir =
         this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
       ConvertToWindowsSlash(artifactDir);
-      this->WriteString("<PropertyGroup>\n", 1);
-      this->WriteString("<AppxPackageArtifactsDir>", 2);
-      (*this->BuildFileStream) << cmVS10EscapeXML(artifactDir)
-                               << "\\</AppxPackageArtifactsDir>\n";
-      this->WriteString("<ProjectPriFullPath>", 2);
+      Elem e1(e0, "PropertyGroup");
+      e1.Element("AppxPackageArtifactsDir", artifactDir + "\\");
       std::string resourcePriFile =
         this->DefaultArtifactDir + "/resources.pri";
       ConvertToWindowsSlash(resourcePriFile);
-      (*this->BuildFileStream) << resourcePriFile << "</ProjectPriFullPath>\n";
+      e1.Element("ProjectPriFullPath", resourcePriFile);
 
       // If we are missing files and we don't have a certificate and
       // aren't targeting WP8.0, add a default certificate
@@ -3865,30 +3892,21 @@ void cmVisualStudio10TargetGenerator::WriteWinRTPackageCertificateKeyFile()
                                  pfxFile, false);
         ConvertToWindowsSlash(pfxFile);
         this->AddedFiles.push_back(pfxFile);
+        this->AddedDefaultCertificate = true;
       }
 
-      this->WriteString("<", 2);
-      (*this->BuildFileStream) << "PackageCertificateKeyFile>" << pfxFile
-                               << "</PackageCertificateKeyFile>\n";
+      e1.Element("PackageCertificateKeyFile", pfxFile);
       std::string thumb = cmSystemTools::ComputeCertificateThumbprint(pfxFile);
       if (!thumb.empty()) {
-        this->WriteString("<PackageCertificateThumbprint>", 2);
-        (*this->BuildFileStream) << thumb
-                                 << "</PackageCertificateThumbprint>\n";
+        e1.Element("PackageCertificateThumbprint", thumb);
       }
-      this->WriteString("</PropertyGroup>\n", 1);
     } else if (!pfxFile.empty()) {
-      this->WriteString("<PropertyGroup>\n", 1);
-      this->WriteString("<", 2);
-      (*this->BuildFileStream) << "PackageCertificateKeyFile>" << pfxFile
-                               << "</PackageCertificateKeyFile>\n";
+      Elem e1(e0, "PropertyGroup");
+      e1.Element("PackageCertificateKeyFile", pfxFile);
       std::string thumb = cmSystemTools::ComputeCertificateThumbprint(pfxFile);
       if (!thumb.empty()) {
-        this->WriteString("<PackageCertificateThumbprint>", 2);
-        (*this->BuildFileStream) << thumb
-                                 << "</PackageCertificateThumbprint>\n";
+        e1.Element("PackageCertificateThumbprint", thumb);
       }
-      this->WriteString("</PropertyGroup>\n", 1);
     }
   }
 }
@@ -3926,54 +3944,37 @@ bool cmVisualStudio10TargetGenerator::IsXamlSource(
   return it != expectedXamlSources.end();
 }
 
-void cmVisualStudio10TargetGenerator::WriteApplicationTypeSettings()
+void cmVisualStudio10TargetGenerator::WriteApplicationTypeSettings(Elem& e1)
 {
-  cmGlobalVisualStudio10Generator* gg =
-    static_cast<cmGlobalVisualStudio10Generator*>(this->GlobalGenerator);
+  cmGlobalVisualStudio10Generator* gg = this->GlobalGenerator;
   bool isAppContainer = false;
   bool const isWindowsPhone = this->GlobalGenerator->TargetsWindowsPhone();
   bool const isWindowsStore = this->GlobalGenerator->TargetsWindowsStore();
   std::string const& v = this->GlobalGenerator->GetSystemVersion();
   if (isWindowsPhone || isWindowsStore) {
-    this->WriteString("<ApplicationType>", 2);
-    (*this->BuildFileStream)
-      << (isWindowsPhone ? "Windows Phone" : "Windows Store")
-      << "</ApplicationType>\n";
-    this->WriteString("<DefaultLanguage>en-US"
-                      "</DefaultLanguage>\n",
-                      2);
+    e1.Element("ApplicationType",
+               (isWindowsPhone ? "Windows Phone" : "Windows Store"));
+    e1.Element("DefaultLanguage", "en-US");
     if (cmHasLiteralPrefix(v, "10.0")) {
-      this->WriteString("<ApplicationTypeRevision>", 2);
-      (*this->BuildFileStream) << cmVS10EscapeXML("10.0")
-                               << "</ApplicationTypeRevision>\n";
+      e1.Element("ApplicationTypeRevision", "10.0");
       // Visual Studio 14.0 is necessary for building 10.0 apps
-      this->WriteString("<MinimumVisualStudioVersion>14.0"
-                        "</MinimumVisualStudioVersion>\n",
-                        2);
+      e1.Element("MinimumVisualStudioVersion", "14.0");
 
       if (this->GeneratorTarget->GetType() < cmStateEnums::UTILITY) {
         isAppContainer = true;
       }
     } else if (v == "8.1") {
-      this->WriteString("<ApplicationTypeRevision>", 2);
-      (*this->BuildFileStream) << cmVS10EscapeXML(v)
-                               << "</ApplicationTypeRevision>\n";
+      e1.Element("ApplicationTypeRevision", v);
       // Visual Studio 12.0 is necessary for building 8.1 apps
-      this->WriteString("<MinimumVisualStudioVersion>12.0"
-                        "</MinimumVisualStudioVersion>\n",
-                        2);
+      e1.Element("MinimumVisualStudioVersion", "12.0");
 
       if (this->GeneratorTarget->GetType() < cmStateEnums::UTILITY) {
         isAppContainer = true;
       }
     } else if (v == "8.0") {
-      this->WriteString("<ApplicationTypeRevision>", 2);
-      (*this->BuildFileStream) << cmVS10EscapeXML(v)
-                               << "</ApplicationTypeRevision>\n";
+      e1.Element("ApplicationTypeRevision", v);
       // Visual Studio 11.0 is necessary for building 8.0 apps
-      this->WriteString("<MinimumVisualStudioVersion>11.0"
-                        "</MinimumVisualStudioVersion>\n",
-                        2);
+      e1.Element("MinimumVisualStudioVersion", "11.0");
 
       if (isWindowsStore &&
           this->GeneratorTarget->GetType() < cmStateEnums::UTILITY) {
@@ -3981,52 +3982,38 @@ void cmVisualStudio10TargetGenerator::WriteApplicationTypeSettings()
       } else if (isWindowsPhone &&
                  this->GeneratorTarget->GetType() ==
                    cmStateEnums::EXECUTABLE) {
-        this->WriteString("<XapOutputs>true</XapOutputs>\n", 2);
-        this->WriteString("<XapFilename>", 2);
-        (*this->BuildFileStream)
-          << cmVS10EscapeXML(this->Name)
-          << "_$(Configuration)_$(Platform).xap</XapFilename>\n";
+        e1.Element("XapOutputs", "true");
+        e1.Element("XapFilename",
+                   this->Name + "_$(Configuration)_$(Platform).xap");
       }
     }
   }
   if (isAppContainer) {
-    this->WriteString("<AppContainerApplication>true"
-                      "</AppContainerApplication>\n",
-                      2);
+    e1.Element("AppContainerApplication", "true");
   } else if (this->Platform == "ARM64") {
-    this->WriteString("<WindowsSDKDesktopARM64Support>true"
-                      "</WindowsSDKDesktopARM64Support>\n",
-                      2);
+    e1.Element("WindowsSDKDesktopARM64Support", "true");
   } else if (this->Platform == "ARM") {
-    this->WriteString("<WindowsSDKDesktopARMSupport>true"
-                      "</WindowsSDKDesktopARMSupport>\n",
-                      2);
+    e1.Element("WindowsSDKDesktopARMSupport", "true");
   }
   std::string const& targetPlatformVersion =
     gg->GetWindowsTargetPlatformVersion();
   if (!targetPlatformVersion.empty()) {
-    this->WriteString("<WindowsTargetPlatformVersion>", 2);
-    (*this->BuildFileStream) << cmVS10EscapeXML(targetPlatformVersion)
-                             << "</WindowsTargetPlatformVersion>\n";
+    e1.Element("WindowsTargetPlatformVersion", targetPlatformVersion);
   }
   const char* targetPlatformMinVersion = this->GeneratorTarget->GetProperty(
     "VS_WINDOWS_TARGET_PLATFORM_MIN_VERSION");
   if (targetPlatformMinVersion) {
-    this->WriteString("<WindowsTargetPlatformMinVersion>", 2);
-    (*this->BuildFileStream) << cmVS10EscapeXML(targetPlatformMinVersion)
-                             << "</WindowsTargetPlatformMinVersion>\n";
+    e1.Element("WindowsTargetPlatformMinVersion", targetPlatformMinVersion);
   } else if (isWindowsStore && cmHasLiteralPrefix(v, "10.0")) {
     // If the min version is not set, then use the TargetPlatformVersion
     if (!targetPlatformVersion.empty()) {
-      this->WriteString("<WindowsTargetPlatformMinVersion>", 2);
-      (*this->BuildFileStream) << cmVS10EscapeXML(targetPlatformVersion)
-                               << "</WindowsTargetPlatformMinVersion>\n";
+      e1.Element("WindowsTargetPlatformMinVersion", targetPlatformVersion);
     }
   }
 
   // Added IoT Startup Task support
   if (this->GeneratorTarget->GetPropertyAsBool("VS_IOT_STARTUP_TASK")) {
-    this->WriteString("<ContainsStartupTask>true</ContainsStartupTask>\n", 2);
+    e1.Element("ContainsStartupTask", "true");
   }
 }
 
@@ -4074,27 +4061,27 @@ void cmVisualStudio10TargetGenerator::VerifyNecessaryFiles()
   }
 }
 
-void cmVisualStudio10TargetGenerator::WriteMissingFiles()
+void cmVisualStudio10TargetGenerator::WriteMissingFiles(Elem& e1)
 {
   std::string const& v = this->GlobalGenerator->GetSystemVersion();
   if (this->GlobalGenerator->TargetsWindowsPhone()) {
     if (v == "8.0") {
-      this->WriteMissingFilesWP80();
+      this->WriteMissingFilesWP80(e1);
     } else if (v == "8.1") {
-      this->WriteMissingFilesWP81();
+      this->WriteMissingFilesWP81(e1);
     }
   } else if (this->GlobalGenerator->TargetsWindowsStore()) {
     if (v == "8.0") {
-      this->WriteMissingFilesWS80();
+      this->WriteMissingFilesWS80(e1);
     } else if (v == "8.1") {
-      this->WriteMissingFilesWS81();
+      this->WriteMissingFilesWS81(e1);
     } else if (cmHasLiteralPrefix(v, "10.0")) {
-      this->WriteMissingFilesWS10_0();
+      this->WriteMissingFilesWS10_0(e1);
     }
   }
 }
 
-void cmVisualStudio10TargetGenerator::WriteMissingFilesWP80()
+void cmVisualStudio10TargetGenerator::WriteMissingFilesWP80(Elem& e1)
 {
   std::string templateFolder =
     cmSystemTools::GetCMakeRoot() + "/Templates/Windows";
@@ -4155,25 +4142,24 @@ void cmVisualStudio10TargetGenerator::WriteMissingFilesWP80()
 
   std::string sourceFile = this->ConvertPath(manifestFile, false);
   ConvertToWindowsSlash(sourceFile);
-  this->WriteString("<Xml Include=\"", 2);
-  (*this->BuildFileStream) << cmVS10EscapeXML(sourceFile) << "\">\n";
-  this->WriteString("<SubType>Designer</SubType>\n", 3);
-  this->WriteString("</Xml>\n", 2);
+  {
+    Elem e2(e1, "Xml");
+    e2.Attribute("Include", sourceFile);
+    e2.Element("SubType", "Designer");
+  }
   this->AddedFiles.push_back(sourceFile);
 
   std::string smallLogo = this->DefaultArtifactDir + "/SmallLogo.png";
   cmSystemTools::CopyAFile(templateFolder + "/SmallLogo.png", smallLogo,
                            false);
   ConvertToWindowsSlash(smallLogo);
-  this->WriteString("<Image Include=\"", 2);
-  (*this->BuildFileStream) << cmVS10EscapeXML(smallLogo) << "\" />\n";
+  Elem(e1, "Image").Attribute("Include", smallLogo);
   this->AddedFiles.push_back(smallLogo);
 
   std::string logo = this->DefaultArtifactDir + "/Logo.png";
   cmSystemTools::CopyAFile(templateFolder + "/Logo.png", logo, false);
   ConvertToWindowsSlash(logo);
-  this->WriteString("<Image Include=\"", 2);
-  (*this->BuildFileStream) << cmVS10EscapeXML(logo) << "\" />\n";
+  Elem(e1, "Image").Attribute("Include", logo);
   this->AddedFiles.push_back(logo);
 
   std::string applicationIcon =
@@ -4181,12 +4167,11 @@ void cmVisualStudio10TargetGenerator::WriteMissingFilesWP80()
   cmSystemTools::CopyAFile(templateFolder + "/ApplicationIcon.png",
                            applicationIcon, false);
   ConvertToWindowsSlash(applicationIcon);
-  this->WriteString("<Image Include=\"", 2);
-  (*this->BuildFileStream) << cmVS10EscapeXML(applicationIcon) << "\" />\n";
+  Elem(e1, "Image").Attribute("Include", applicationIcon);
   this->AddedFiles.push_back(applicationIcon);
 }
 
-void cmVisualStudio10TargetGenerator::WriteMissingFilesWP81()
+void cmVisualStudio10TargetGenerator::WriteMissingFilesWP81(Elem& e1)
 {
   std::string manifestFile =
     this->DefaultArtifactDir + "/package.appxManifest";
@@ -4246,10 +4231,10 @@ void cmVisualStudio10TargetGenerator::WriteMissingFilesWP81()
     "</Package>\n";
   /* clang-format on */
 
-  this->WriteCommonMissingFiles(manifestFile);
+  this->WriteCommonMissingFiles(e1, manifestFile);
 }
 
-void cmVisualStudio10TargetGenerator::WriteMissingFilesWS80()
+void cmVisualStudio10TargetGenerator::WriteMissingFilesWS80(Elem& e1)
 {
   std::string manifestFile =
     this->DefaultArtifactDir + "/package.appxManifest";
@@ -4301,10 +4286,10 @@ void cmVisualStudio10TargetGenerator::WriteMissingFilesWS80()
     "</Package>\n";
   /* clang-format on */
 
-  this->WriteCommonMissingFiles(manifestFile);
+  this->WriteCommonMissingFiles(e1, manifestFile);
 }
 
-void cmVisualStudio10TargetGenerator::WriteMissingFilesWS81()
+void cmVisualStudio10TargetGenerator::WriteMissingFilesWS81(Elem& e1)
 {
   std::string manifestFile =
     this->DefaultArtifactDir + "/package.appxManifest";
@@ -4361,10 +4346,10 @@ void cmVisualStudio10TargetGenerator::WriteMissingFilesWS81()
     "</Package>\n";
   /* clang-format on */
 
-  this->WriteCommonMissingFiles(manifestFile);
+  this->WriteCommonMissingFiles(e1, manifestFile);
 }
 
-void cmVisualStudio10TargetGenerator::WriteMissingFilesWS10_0()
+void cmVisualStudio10TargetGenerator::WriteMissingFilesWS10_0(Elem& e1)
 {
   std::string manifestFile =
     this->DefaultArtifactDir + "/package.appxManifest";
@@ -4422,67 +4407,65 @@ void cmVisualStudio10TargetGenerator::WriteMissingFilesWS10_0()
     "</Package>\n";
   /* clang-format on */
 
-  this->WriteCommonMissingFiles(manifestFile);
+  this->WriteCommonMissingFiles(e1, manifestFile);
 }
 
 void cmVisualStudio10TargetGenerator::WriteCommonMissingFiles(
-  const std::string& manifestFile)
+  Elem& e1, const std::string& manifestFile)
 {
   std::string templateFolder =
     cmSystemTools::GetCMakeRoot() + "/Templates/Windows";
 
   std::string sourceFile = this->ConvertPath(manifestFile, false);
   ConvertToWindowsSlash(sourceFile);
-  this->WriteString("<AppxManifest Include=\"", 2);
-  (*this->BuildFileStream) << cmVS10EscapeXML(sourceFile) << "\">\n";
-  this->WriteString("<SubType>Designer</SubType>\n", 3);
-  this->WriteString("</AppxManifest>\n", 2);
+  {
+    Elem e2(e1, "AppxManifest");
+    e2.Attribute("Include", sourceFile);
+    e2.Element("SubType", "Designer");
+  }
   this->AddedFiles.push_back(sourceFile);
 
   std::string smallLogo = this->DefaultArtifactDir + "/SmallLogo.png";
   cmSystemTools::CopyAFile(templateFolder + "/SmallLogo.png", smallLogo,
                            false);
   ConvertToWindowsSlash(smallLogo);
-  this->WriteString("<Image Include=\"", 2);
-  (*this->BuildFileStream) << cmVS10EscapeXML(smallLogo) << "\" />\n";
+  Elem(e1, "Image").Attribute("Include", smallLogo);
   this->AddedFiles.push_back(smallLogo);
 
   std::string smallLogo44 = this->DefaultArtifactDir + "/SmallLogo44x44.png";
   cmSystemTools::CopyAFile(templateFolder + "/SmallLogo44x44.png", smallLogo44,
                            false);
   ConvertToWindowsSlash(smallLogo44);
-  this->WriteString("<Image Include=\"", 2);
-  (*this->BuildFileStream) << cmVS10EscapeXML(smallLogo44) << "\" />\n";
+  Elem(e1, "Image").Attribute("Include", smallLogo44);
   this->AddedFiles.push_back(smallLogo44);
 
   std::string logo = this->DefaultArtifactDir + "/Logo.png";
   cmSystemTools::CopyAFile(templateFolder + "/Logo.png", logo, false);
   ConvertToWindowsSlash(logo);
-  this->WriteString("<Image Include=\"", 2);
-  (*this->BuildFileStream) << cmVS10EscapeXML(logo) << "\" />\n";
+  Elem(e1, "Image").Attribute("Include", logo);
   this->AddedFiles.push_back(logo);
 
   std::string storeLogo = this->DefaultArtifactDir + "/StoreLogo.png";
   cmSystemTools::CopyAFile(templateFolder + "/StoreLogo.png", storeLogo,
                            false);
   ConvertToWindowsSlash(storeLogo);
-  this->WriteString("<Image Include=\"", 2);
-  (*this->BuildFileStream) << cmVS10EscapeXML(storeLogo) << "\" />\n";
+  Elem(e1, "Image").Attribute("Include", storeLogo);
   this->AddedFiles.push_back(storeLogo);
 
   std::string splashScreen = this->DefaultArtifactDir + "/SplashScreen.png";
   cmSystemTools::CopyAFile(templateFolder + "/SplashScreen.png", splashScreen,
                            false);
   ConvertToWindowsSlash(splashScreen);
-  this->WriteString("<Image Include=\"", 2);
-  (*this->BuildFileStream) << cmVS10EscapeXML(splashScreen) << "\" />\n";
+  Elem(e1, "Image").Attribute("Include", splashScreen);
   this->AddedFiles.push_back(splashScreen);
 
-  // This file has already been added to the build so don't copy it
-  std::string keyFile = this->DefaultArtifactDir + "/Windows_TemporaryKey.pfx";
-  ConvertToWindowsSlash(keyFile);
-  this->WriteString("<None Include=\"", 2);
-  (*this->BuildFileStream) << cmVS10EscapeXML(keyFile) << "\" />\n";
+  if (this->AddedDefaultCertificate) {
+    // This file has already been added to the build so don't copy it
+    std::string keyFile =
+      this->DefaultArtifactDir + "/Windows_TemporaryKey.pfx";
+    ConvertToWindowsSlash(keyFile);
+    Elem(e1, "None").Attribute("Include", keyFile);
+  }
 }
 
 bool cmVisualStudio10TargetGenerator::ForceOld(const std::string& source) const
@@ -4528,13 +4511,11 @@ void cmVisualStudio10TargetGenerator::GetCSharpSourceProperties(
 }
 
 void cmVisualStudio10TargetGenerator::WriteCSharpSourceProperties(
-  const std::map<std::string, std::string>& tags)
+  Elem& e2, const std::map<std::string, std::string>& tags)
 {
   if (!tags.empty()) {
     for (const auto& i : tags) {
-      this->WriteString("<", 3);
-      (*this->BuildFileStream) << i.first << ">" << cmVS10EscapeXML(i.second)
-                               << "</" << i.first << ">\n";
+      e2.Element(i.first.c_str(), i.second);
     }
   }
 }
@@ -4542,14 +4523,17 @@ void cmVisualStudio10TargetGenerator::WriteCSharpSourceProperties(
 void cmVisualStudio10TargetGenerator::GetCSharpSourceLink(
   cmSourceFile const* sf, std::string& link)
 {
-  std::string f = sf->GetFullPath();
-  if (!this->InSourceBuild) {
+  std::string const& sourceFilePath = sf->GetFullPath();
+  std::string const& binaryDir = LocalGenerator->GetCurrentBinaryDirectory();
+
+  if (!cmSystemTools::IsSubDirectory(sourceFilePath, binaryDir)) {
     const std::string stripFromPath =
       this->Makefile->GetCurrentSourceDirectory();
-    if (f.find(stripFromPath) != std::string::npos) {
-      link = f.substr(stripFromPath.length() + 1);
+    if (sourceFilePath.find(stripFromPath) == 0) {
       if (const char* l = sf->GetProperty("VS_CSHARP_Link")) {
         link = l;
+      } else {
+        link = sourceFilePath.substr(stripFromPath.length() + 1);
       }
       ConvertToWindowsSlash(link);
     }
diff --git a/Source/cmVisualStudio10TargetGenerator.h b/Source/cmVisualStudio10TargetGenerator.h
index 33d4fb775..15e47b4b0 100644
--- a/Source/cmVisualStudio10TargetGenerator.h
+++ b/Source/cmVisualStudio10TargetGenerator.h
@@ -17,11 +17,11 @@ class cmCustomCommand;
 class cmGeneratedFileStream;
 class cmGeneratorTarget;
 class cmGlobalVisualStudio10Generator;
-class cmLocalVisualStudio7Generator;
+class cmLocalVisualStudio10Generator;
 class cmMakefile;
 class cmSourceFile;
 class cmSourceGroup;
-class cmVisualStudioGeneratorOptions;
+class cmVS10GeneratorOptions;
 
 class cmVisualStudio10TargetGenerator
 {
@@ -32,10 +32,6 @@ public:
                                   cmGlobalVisualStudio10Generator* gg);
   ~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);
 
 private:
   struct ToolSource
@@ -53,107 +49,116 @@ private:
     std::vector<std::string> Configs;
   };
 
+  struct Elem;
+  struct OptionsHelper;
+
   std::string ConvertPath(std::string const& path, bool forceRelative);
-  void WriteString(const char* line, int indentLevel);
-  void WriteProjectConfigurations();
-  void WriteProjectConfigurationValues();
-  void WriteMSToolConfigurationValues(std::string const& config);
-  void WriteMSToolConfigurationValuesManaged(std::string const& config);
-  void WriteHeaderSource(cmSourceFile const* sf);
-  void WriteExtraSource(cmSourceFile const* sf);
-  void WriteNsightTegraConfigurationValues(std::string const& config);
-  void WriteSource(std::string const& tool, cmSourceFile const* sf,
-                   const char* end = 0);
-  void WriteExcludeFromBuild(std::vector<size_t> const& exclude_configs);
-  void WriteAllSources();
-  void WriteDotNetReferences();
-  void WriteDotNetReference(std::string const& ref, std::string const& hint);
-  void WriteDotNetReferenceCustomTags(std::string const& ref);
-  void WriteEmbeddedResourceGroup();
-  void WriteWinRTReferences();
-  void WriteWinRTPackageCertificateKeyFile();
-  void WriteXamlFilesGroup();
-  void WritePathAndIncrementalLinkOptions();
-  void WriteItemDefinitionGroups();
+  std::string CalcCondition(const std::string& config) const;
+  void WriteProjectConfigurations(Elem& e0);
+  void WriteProjectConfigurationValues(Elem& e0);
+  void WriteMSToolConfigurationValues(Elem& e1, std::string const& config);
+  void WriteMSToolConfigurationValuesManaged(Elem& e1,
+                                             std::string const& config);
+  void WriteHeaderSource(Elem& e1, cmSourceFile const* sf);
+  void WriteExtraSource(Elem& e1, cmSourceFile const* sf);
+  void WriteNsightTegraConfigurationValues(Elem& e1,
+                                           std::string const& config);
+  void WriteSource(Elem& e2, std::string const& tool, cmSourceFile const* sf);
+  void WriteExcludeFromBuild(Elem& e2,
+                             std::vector<size_t> const& exclude_configs);
+  void WriteAllSources(Elem& e0);
+  void WriteDotNetReferences(Elem& e0);
+  void WriteDotNetReference(Elem& e1, std::string const& ref,
+                            std::string const& hint,
+                            std::string const& config);
+  void WriteDotNetReferenceCustomTags(Elem& e2, std::string const& ref);
+  void WriteEmbeddedResourceGroup(Elem& e0);
+  void WriteWinRTReferences(Elem& e0);
+  void WriteWinRTPackageCertificateKeyFile(Elem& e0);
+  void WriteXamlFilesGroup(Elem& e0);
+  void WritePathAndIncrementalLinkOptions(Elem& e0);
+  void WriteItemDefinitionGroups(Elem& e0);
   void VerifyNecessaryFiles();
-  void WriteMissingFiles();
-  void WriteMissingFilesWP80();
-  void WriteMissingFilesWP81();
-  void WriteMissingFilesWS80();
-  void WriteMissingFilesWS81();
-  void WriteMissingFilesWS10_0();
-  void WritePlatformExtensions();
-  void WriteSinglePlatformExtension(std::string const& extension,
+  void WriteMissingFiles(Elem& e1);
+  void WriteMissingFilesWP80(Elem& e1);
+  void WriteMissingFilesWP81(Elem& e1);
+  void WriteMissingFilesWS80(Elem& e1);
+  void WriteMissingFilesWS81(Elem& e1);
+  void WriteMissingFilesWS10_0(Elem& e1);
+  void WritePlatformExtensions(Elem& e1);
+  void WriteSinglePlatformExtension(Elem& e1, std::string const& extension,
                                     std::string const& version);
-  void WriteSDKReferences();
-  void WriteSingleSDKReference(std::string const& extension,
+  void WriteSDKReferences(Elem& e0);
+  void WriteSingleSDKReference(Elem& e1, std::string const& extension,
                                std::string const& version);
-  void WriteCommonMissingFiles(const std::string& manifestFile);
-  void WriteTargetSpecificReferences();
-  void WriteTargetsFileReferences();
+  void WriteCommonMissingFiles(Elem& e1, const std::string& manifestFile);
+  void WriteTargetSpecificReferences(Elem& e0);
+  void WriteTargetsFileReferences(Elem& e1);
 
   std::vector<std::string> GetIncludes(std::string const& config,
                                        std::string const& lang) const;
 
   bool ComputeClOptions();
   bool ComputeClOptions(std::string const& configName);
-  void WriteClOptions(std::string const& config);
+  void WriteClOptions(Elem& e1, std::string const& config);
   bool ComputeRcOptions();
   bool ComputeRcOptions(std::string const& config);
-  void WriteRCOptions(std::string const& config);
+  void WriteRCOptions(Elem& e1, std::string const& config);
   bool ComputeCudaOptions();
   bool ComputeCudaOptions(std::string const& config);
-  void WriteCudaOptions(std::string const& config);
+  void WriteCudaOptions(Elem& e1, std::string const& config);
 
   bool ComputeCudaLinkOptions();
   bool ComputeCudaLinkOptions(std::string const& config);
-  void WriteCudaLinkOptions(std::string const& config);
+  void WriteCudaLinkOptions(Elem& e1, std::string const& config);
 
   bool ComputeMasmOptions();
   bool ComputeMasmOptions(std::string const& config);
-  void WriteMasmOptions(std::string const& config);
+  void WriteMasmOptions(Elem& e1, std::string const& config);
   bool ComputeNasmOptions();
   bool ComputeNasmOptions(std::string const& config);
-  void WriteNasmOptions(std::string const& config);
+  void WriteNasmOptions(Elem& e1, std::string const& config);
 
   bool ComputeLinkOptions();
   bool ComputeLinkOptions(std::string const& config);
   bool ComputeLibOptions();
   bool ComputeLibOptions(std::string const& config);
-  void WriteLinkOptions(std::string const& config);
-  void WriteMidlOptions(std::string const& config);
-  void WriteAntBuildOptions(std::string const& config);
-  void OutputLinkIncremental(std::string const& configName);
-  void WriteCustomRule(cmSourceFile const* source,
+  void WriteLinkOptions(Elem& e1, std::string const& config);
+  void WriteMidlOptions(Elem& e1, std::string const& config);
+  void WriteAntBuildOptions(Elem& e1, std::string const& config);
+  void OutputLinkIncremental(Elem& e1, std::string const& configName);
+  void WriteCustomRule(Elem& e0, cmSourceFile const* source,
                        cmCustomCommand const& command);
-  void WriteCustomRuleCpp(std::string const& config, std::string const& script,
-                          std::string const& inputs,
+  void WriteCustomRuleCpp(Elem& e2, std::string const& config,
+                          std::string const& script, std::string const& inputs,
                           std::string const& outputs,
                           std::string const& comment);
-  void WriteCustomRuleCSharp(std::string const& config,
+  void WriteCustomRuleCSharp(Elem& e0, std::string const& config,
                              std::string const& commandName,
                              std::string const& script,
                              std::string const& inputs,
                              std::string const& outputs,
                              std::string const& comment);
-  void WriteCustomCommands();
-  void WriteCustomCommand(cmSourceFile const* sf);
+  void WriteCustomCommands(Elem& e0);
+  void WriteCustomCommand(Elem& e0, cmSourceFile const* sf);
   void WriteGroups();
-  void WriteProjectReferences();
-  void WriteApplicationTypeSettings();
-  bool OutputSourceSpecificFlags(cmSourceFile const* source);
-  void AddLibraries(cmComputeLinkInformation& cli,
+  void WriteProjectReferences(Elem& e0);
+  void WriteApplicationTypeSettings(Elem& e1);
+  void OutputSourceSpecificFlags(Elem& e2, cmSourceFile const* source);
+  void AddLibraries(const cmComputeLinkInformation& cli,
                     std::vector<std::string>& libVec,
-                    std::vector<std::string>& vsTargetVec);
+                    std::vector<std::string>& vsTargetVec,
+                    const std::string& config);
   void AddTargetsFileAndConfigPair(std::string const& targetsFile,
                                    std::string const& config);
-  void WriteLibOptions(std::string const& config);
-  void WriteManifestOptions(std::string const& config);
-  void WriteEvents(std::string const& configName);
-  void WriteEvent(const char* name,
+  void WriteLibOptions(Elem& e1, std::string const& config);
+  void WriteManifestOptions(Elem& e1, std::string const& config);
+  void WriteEvents(Elem& e1, std::string const& configName);
+  void WriteEvent(Elem& e1, const char* name,
                   std::vector<cmCustomCommand> const& commands,
                   std::string const& configName);
-  void WriteGroupSources(const char* name, ToolSources const& sources,
+  void WriteGroupSources(Elem& e0, std::string const& name,
+                         ToolSources const& sources,
                          std::vector<cmSourceGroup>&);
   void AddMissingSourceGroups(std::set<cmSourceGroup*>& groupsUsed,
                               const std::vector<cmSourceGroup>& allGroups);
@@ -166,11 +171,12 @@ private:
   void GetCSharpSourceProperties(cmSourceFile const* sf,
                                  std::map<std::string, std::string>& tags);
   void WriteCSharpSourceProperties(
-    const std::map<std::string, std::string>& tags);
+    Elem& e2, const std::map<std::string, std::string>& tags);
   void GetCSharpSourceLink(cmSourceFile const* sf, std::string& link);
 
 private:
-  typedef cmVisualStudioGeneratorOptions Options;
+  friend class cmVS10GeneratorOptions;
+  typedef cmVS10GeneratorOptions Options;
   typedef std::map<std::string, std::unique_ptr<Options>> OptionsMap;
   OptionsMap ClOptions;
   OptionsMap RcOptions;
@@ -180,8 +186,6 @@ private:
   OptionsMap NasmOptions;
   OptionsMap LinkOptions;
   std::string LangForClCompile;
-  std::string PathToProjectFile;
-  std::string ProjectFileExtension;
   enum VsProjectType
   {
     vcxproj,
@@ -190,24 +194,32 @@ private:
   bool InSourceBuild;
   std::vector<std::string> Configurations;
   std::vector<TargetsFileAndConfigs> TargetsFileAndConfigsVec;
-  cmGeneratorTarget* GeneratorTarget;
-  cmMakefile* Makefile;
-  std::string Platform;
-  std::string GUID;
-  std::string Name;
+  cmGeneratorTarget* const GeneratorTarget;
+  cmMakefile* const Makefile;
+  std::string const Platform;
+  std::string const Name;
+  std::string const GUID;
   bool MSTools;
   bool Managed;
   bool NsightTegra;
-  int NsightTegraVersion[4];
+  unsigned int NsightTegraVersion[4];
   bool TargetCompileAsWinRT;
-  cmGlobalVisualStudio10Generator* GlobalGenerator;
-  cmGeneratedFileStream* BuildFileStream;
-  cmLocalVisualStudio7Generator* LocalGenerator;
-  std::set<cmSourceFile const*> SourcesVisited;
+  cmGlobalVisualStudio10Generator* const GlobalGenerator;
+  cmLocalVisualStudio10Generator* const LocalGenerator;
   std::set<std::string> CSharpCustomCommandNames;
   bool IsMissingFiles;
   std::vector<std::string> AddedFiles;
   std::string DefaultArtifactDir;
+  bool AddedDefaultCertificate = false;
+  // managed C++/C# relevant members
+  typedef std::pair<std::string, std::string> DotNetHintReference;
+  typedef std::vector<DotNetHintReference> DotNetHintReferenceList;
+  typedef std::map<std::string, DotNetHintReferenceList>
+    DotNetHintReferenceMap;
+  DotNetHintReferenceMap DotNetHintReferences;
+  typedef std::set<std::string> UsingDirectories;
+  typedef std::map<std::string, UsingDirectories> UsingDirectoriesMap;
+  UsingDirectoriesMap AdditionalUsingDirectories;
 
   typedef std::map<std::string, ToolSources> ToolSourceMap;
   ToolSourceMap Tools;
diff --git a/Source/cmVisualStudioGeneratorOptions.cxx b/Source/cmVisualStudioGeneratorOptions.cxx
index ccbff83e6..4afef8b2f 100644
--- a/Source/cmVisualStudioGeneratorOptions.cxx
+++ b/Source/cmVisualStudioGeneratorOptions.cxx
@@ -4,43 +4,19 @@
 #include "cmLocalVisualStudioGenerator.h"
 #include "cmOutputConverter.h"
 #include "cmSystemTools.h"
-#include "cmVisualStudio10TargetGenerator.h"
 
-static std::string cmVisualStudio10GeneratorOptionsEscapeForXML(
-  std::string ret)
+static void cmVS10EscapeForMSBuild(std::string& ret)
 {
   cmSystemTools::ReplaceString(ret, ";", "%3B");
-  cmSystemTools::ReplaceString(ret, "&", "&amp;");
-  cmSystemTools::ReplaceString(ret, "<", "&lt;");
-  cmSystemTools::ReplaceString(ret, ">", "&gt;");
-  return ret;
-}
-
-static std::string cmVisualStudioGeneratorOptionsEscapeForXML(std::string ret)
-{
-  cmSystemTools::ReplaceString(ret, "&", "&amp;");
-  cmSystemTools::ReplaceString(ret, "\"", "&quot;");
-  cmSystemTools::ReplaceString(ret, "<", "&lt;");
-  cmSystemTools::ReplaceString(ret, ">", "&gt;");
-  cmSystemTools::ReplaceString(ret, "\n", "&#x0D;&#x0A;");
-  return ret;
-}
-
-cmVisualStudioGeneratorOptions::cmVisualStudioGeneratorOptions(
-  cmLocalVisualStudioGenerator* lg, Tool tool,
-  cmVisualStudio10TargetGenerator* g)
-  : cmVisualStudioGeneratorOptions(lg, tool, nullptr, nullptr, g)
-{
 }
 
 cmVisualStudioGeneratorOptions::cmVisualStudioGeneratorOptions(
   cmLocalVisualStudioGenerator* lg, Tool tool, cmVS7FlagTable const* table,
-  cmVS7FlagTable const* extraTable, cmVisualStudio10TargetGenerator* g)
+  cmVS7FlagTable const* extraTable)
   : cmIDEOptions()
   , LocalGenerator(lg)
   , Version(lg->GetVersion())
   , CurrentTool(tool)
-  , TargetGenerator(g)
 {
   // Store the given flag tables.
   this->AddTable(table);
@@ -151,10 +127,9 @@ bool cmVisualStudioGeneratorOptions::IsManaged() 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") {
+  // Look for a _UNICODE definition.
+  for (std::string const& di : this->Defines) {
+    if (di == "_UNICODE") {
       return true;
     }
   }
@@ -162,10 +137,9 @@ bool cmVisualStudioGeneratorOptions::UsingUnicode() const
 }
 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") {
+  // Look for a _SBCS definition.
+  for (std::string const& di : this->Defines) {
+    if (di == "_SBCS") {
       return true;
     }
   }
@@ -227,7 +201,7 @@ void cmVisualStudioGeneratorOptions::FixCudaCodeGeneration()
       // It translates to -arch=<virtual> -code=<real>.
       cmSystemTools::ReplaceString(arch_name, "sm_", "compute_");
     }
-    for (auto const& c : codes) {
+    for (std::string const& c : codes) {
       std::string entry = arch_name + "," + c;
       result.push_back(entry);
     }
@@ -237,7 +211,7 @@ void cmVisualStudioGeneratorOptions::FixCudaCodeGeneration()
   // -gencode=<arch>,<code>
   // -gencode=<arch>,[<code1>,<code2>]
   // -gencode=<arch>,"<code1>,<code2>"
-  for (auto const& e : gencode) {
+  for (std::string const& e : gencode) {
     std::string entry = e;
     cmSystemTools::ReplaceString(entry, "arch=", "");
     cmSystemTools::ReplaceString(entry, "code=", "");
@@ -285,7 +259,7 @@ void cmVisualStudioGeneratorOptions::FixManifestUACFlags()
   uacExecuteLevelMap["highestAvailable"] = "HighestAvailable";
   uacExecuteLevelMap["requireAdministrator"] = "RequireAdministrator";
 
-  for (auto const& subopt : subOptions) {
+  for (std::string const& subopt : subOptions) {
     std::vector<std::string> keyValue;
     cmsys::SystemTools::Split(subopt, keyValue, '=');
     if (keyValue.size() != 2 || (uacMap.find(keyValue[0]) == uacMap.end())) {
@@ -332,9 +306,8 @@ 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) {
-    this->HandleFlag(ai->c_str());
+  for (std::string const& ai : args) {
+    this->HandleFlag(ai);
   }
 }
 
@@ -396,23 +369,23 @@ void cmVisualStudioGeneratorOptions::Reparse(std::string const& key)
   this->Parse(original.c_str());
 }
 
-void cmVisualStudioGeneratorOptions::StoreUnknownFlag(const char* flag)
+void cmVisualStudioGeneratorOptions::StoreUnknownFlag(std::string const& 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 (flag == "/dbglibs") {
       this->FortranRuntimeDebug = true;
       return;
     }
-    if (strcmp(flag, "/threads") == 0) {
+    if (flag == "/threads") {
       this->FortranRuntimeMT = true;
       return;
     }
-    if (strcmp(flag, "/libs:dll") == 0) {
+    if (flag == "/libs:dll") {
       this->FortranRuntimeDLL = true;
       return;
     }
-    if (strcmp(flag, "/libs:static") == 0) {
+    if (flag == "/libs:static") {
       this->FortranRuntimeDLL = false;
       return;
     }
@@ -420,7 +393,8 @@ void cmVisualStudioGeneratorOptions::StoreUnknownFlag(const char* flag)
 
   // This option is not known.  Store it in the output flags.
   std::string const opts = cmOutputConverter::EscapeWindowsShellArgument(
-    flag, cmOutputConverter::Shell_Flag_AllowMakeVariables |
+    flag.c_str(),
+    cmOutputConverter::Shell_Flag_AllowMakeVariables |
       cmOutputConverter::Shell_Flag_VSIDE);
   this->AppendFlagString(this->UnknownFlagField, opts);
 }
@@ -437,14 +411,19 @@ cmIDEOptions::FlagValue cmVisualStudioGeneratorOptions::TakeFlag(
   return value;
 }
 
-void cmVisualStudioGeneratorOptions::SetConfiguration(const char* config)
+void cmVisualStudioGeneratorOptions::SetConfiguration(
+  const std::string& config)
 {
   this->Configuration = config;
 }
 
+const std::string& cmVisualStudioGeneratorOptions::GetConfiguration() const
+{
+  return this->Configuration;
+}
+
 void cmVisualStudioGeneratorOptions::OutputPreprocessorDefinitions(
-  std::ostream& fout, const char* prefix, const char* suffix,
-  const std::string& lang)
+  std::ostream& fout, int indent, const std::string& lang)
 {
   if (this->Defines.empty()) {
     return;
@@ -453,19 +432,8 @@ void cmVisualStudioGeneratorOptions::OutputPreprocessorDefinitions(
   if (lang == "CUDA") {
     tag = "Defines";
   }
-  if (this->Version >= cmGlobalVisualStudioGenerator::VS10) {
-    // if there are configuration specific flags, then
-    // use the configuration specific tag for PreprocessorDefinitions
-    if (!this->Configuration.empty()) {
-      fout << prefix;
-      this->TargetGenerator->WritePlatformConfigTag(
-        tag, this->Configuration.c_str(), 0, 0, 0, &fout);
-    } else {
-      fout << prefix << "<" << tag << ">";
-    }
-  } else {
-    fout << prefix << tag << "=\"";
-  }
+
+  std::ostringstream oss;
   const char* sep = "";
   std::vector<std::string>::const_iterator de =
     cmRemoveDuplicates(this->Defines);
@@ -474,34 +442,30 @@ void cmVisualStudioGeneratorOptions::OutputPreprocessorDefinitions(
     // Escape the definition for the compiler.
     std::string define;
     if (this->Version < cmGlobalVisualStudioGenerator::VS10) {
-      define = this->LocalGenerator->EscapeForShell(di->c_str(), true);
+      define = this->LocalGenerator->EscapeForShell(*di, true);
     } else {
       define = *di;
     }
-    // Escape this flag for the IDE.
+    // Escape this flag for the MSBuild.
     if (this->Version >= cmGlobalVisualStudioGenerator::VS10) {
-      define = cmVisualStudio10GeneratorOptionsEscapeForXML(define);
-
+      cmVS10EscapeForMSBuild(define);
       if (lang == "RC") {
         cmSystemTools::ReplaceString(define, "\"", "\\\"");
       }
-    } else {
-      define = cmVisualStudioGeneratorOptionsEscapeForXML(define);
     }
     // Store the flag in the project file.
-    fout << sep << define;
+    oss << sep << define;
     sep = ";";
   }
   if (this->Version >= cmGlobalVisualStudioGenerator::VS10) {
-    fout << ";%(" << tag << ")</" << tag << ">" << suffix;
-  } else {
-    fout << "\"" << suffix;
+    oss << ";%(" << tag << ")";
   }
+
+  this->OutputFlag(fout, indent, tag, oss.str());
 }
 
 void cmVisualStudioGeneratorOptions::OutputAdditionalIncludeDirectories(
-  std::ostream& fout, const char* prefix, const char* suffix,
-  const std::string& lang)
+  std::ostream& fout, int indent, const std::string& lang)
 {
   if (this->Includes.empty()) {
     return;
@@ -514,20 +478,7 @@ void cmVisualStudioGeneratorOptions::OutputAdditionalIncludeDirectories(
     tag = "IncludePaths";
   }
 
-  if (this->Version >= cmGlobalVisualStudioGenerator::VS10) {
-    // if there are configuration specific flags, then
-    // use the configuration specific tag for PreprocessorDefinitions
-    if (!this->Configuration.empty()) {
-      fout << prefix;
-      this->TargetGenerator->WritePlatformConfigTag(
-        tag, this->Configuration.c_str(), 0, 0, 0, &fout);
-    } else {
-      fout << prefix << "<" << tag << ">";
-    }
-  } else {
-    fout << prefix << tag << "=\"";
-  }
-
+  std::ostringstream oss;
   const char* sep = "";
   for (std::string include : this->Includes) {
     // first convert all of the slashes
@@ -541,59 +492,40 @@ void cmVisualStudioGeneratorOptions::OutputAdditionalIncludeDirectories(
       include += "\\";
     }
 
-    // Escape this include for the IDE.
-    fout << sep << (this->Version >= cmGlobalVisualStudioGenerator::VS10
-                      ? cmVisualStudio10GeneratorOptionsEscapeForXML(include)
-                      : cmVisualStudioGeneratorOptionsEscapeForXML(include));
+    // Escape this include for the MSBuild.
+    if (this->Version >= cmGlobalVisualStudioGenerator::VS10) {
+      cmVS10EscapeForMSBuild(include);
+    }
+    oss << sep << include;
     sep = ";";
 
     if (lang == "Fortran") {
       include += "/$(ConfigurationName)";
-      fout << sep << (this->Version >= cmGlobalVisualStudioGenerator::VS10
-                        ? cmVisualStudio10GeneratorOptionsEscapeForXML(include)
-                        : cmVisualStudioGeneratorOptionsEscapeForXML(include));
+      oss << sep << include;
     }
   }
 
   if (this->Version >= cmGlobalVisualStudioGenerator::VS10) {
-    fout << sep << "%(" << tag << ")</" << tag << ">" << suffix;
-  } else {
-    fout << "\"" << suffix;
+    oss << sep << "%(" << tag << ")";
   }
+
+  this->OutputFlag(fout, indent, tag, oss.str());
 }
 
 void cmVisualStudioGeneratorOptions::OutputFlagMap(std::ostream& fout,
-                                                   const char* indent)
+                                                   int indent)
 {
-  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()) {
-        this->TargetGenerator->WritePlatformConfigTag(
-          m->first.c_str(), this->Configuration.c_str(), 0, 0, 0, &fout);
-      } else {
-        fout << "<" << m->first << ">";
+  for (auto const& m : this->FlagMap) {
+    std::ostringstream oss;
+    const char* sep = "";
+    for (std::string i : m.second) {
+      if (this->Version >= cmGlobalVisualStudioGenerator::VS10) {
+        cmVS10EscapeForMSBuild(i);
       }
-      const char* sep = "";
-      for (std::vector<std::string>::iterator i = m->second.begin();
-           i != m->second.end(); ++i) {
-        fout << sep << cmVisualStudio10GeneratorOptionsEscapeForXML(*i);
-        sep = ";";
-      }
-      fout << "</" << m->first << ">\n";
-    }
-  } 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) {
-        fout << sep << cmVisualStudioGeneratorOptionsEscapeForXML(*i);
-        sep = ";";
-      }
-      fout << "\"\n";
+      oss << sep << i;
+      sep = ";";
     }
+
+    this->OutputFlag(fout, indent, m.first.c_str(), oss.str());
   }
 }
diff --git a/Source/cmVisualStudioGeneratorOptions.h b/Source/cmVisualStudioGeneratorOptions.h
index 2dffe9b8c..c6b594dbc 100644
--- a/Source/cmVisualStudioGeneratorOptions.h
+++ b/Source/cmVisualStudioGeneratorOptions.h
@@ -16,8 +16,6 @@ class cmLocalVisualStudioGenerator;
 
 typedef cmIDEFlagTable cmVS7FlagTable;
 
-class cmVisualStudio10TargetGenerator;
-
 class cmVisualStudioGeneratorOptions : public cmIDEOptions
 {
 public:
@@ -34,12 +32,8 @@ public:
     CSharpCompiler
   };
   cmVisualStudioGeneratorOptions(cmLocalVisualStudioGenerator* lg, Tool tool,
-                                 cmVS7FlagTable const* table,
-                                 cmVS7FlagTable const* extraTable = 0,
-                                 cmVisualStudio10TargetGenerator* g = 0);
-
-  cmVisualStudioGeneratorOptions(cmLocalVisualStudioGenerator* lg, Tool tool,
-                                 cmVisualStudio10TargetGenerator* g = 0);
+                                 cmVS7FlagTable const* table = nullptr,
+                                 cmVS7FlagTable const* extraTable = nullptr);
 
   // Add a table of flags.
   void AddTable(cmVS7FlagTable const* table);
@@ -83,15 +77,17 @@ public:
   bool IsWinRt() const;
   bool IsManaged() const;
   // Write options to output.
-  void OutputPreprocessorDefinitions(std::ostream& fout, const char* prefix,
-                                     const char* suffix,
+  void OutputPreprocessorDefinitions(std::ostream& fout, int indent,
                                      const std::string& lang);
-  void OutputAdditionalIncludeDirectories(std::ostream& fout,
-                                          const char* prefix,
-                                          const char* suffix,
+  void OutputAdditionalIncludeDirectories(std::ostream& fout, int indent,
                                           const std::string& lang);
-  void OutputFlagMap(std::ostream& fout, const char* indent);
-  void SetConfiguration(const char* config);
+  void OutputFlagMap(std::ostream& fout, int indent);
+  void SetConfiguration(const std::string& config);
+  const std::string& GetConfiguration() const;
+
+protected:
+  virtual void OutputFlag(std::ostream& fout, int indent, const char* tag,
+                          const std::string& content) = 0;
 
 private:
   cmLocalVisualStudioGenerator* LocalGenerator;
@@ -99,7 +95,6 @@ private:
 
   std::string Configuration;
   Tool CurrentTool;
-  cmVisualStudio10TargetGenerator* TargetGenerator;
 
   bool FortranRuntimeDebug;
   bool FortranRuntimeDLL;
@@ -107,7 +102,7 @@ private:
 
   std::string UnknownFlagField;
 
-  virtual void StoreUnknownFlag(const char* flag);
+  void StoreUnknownFlag(std::string const& flag) override;
 
   FlagValue TakeFlag(std::string const& key);
 };
diff --git a/Source/cmWhileCommand.cxx b/Source/cmWhileCommand.cxx
index a08003450..d5bcfc230 100644
--- a/Source/cmWhileCommand.cxx
+++ b/Source/cmWhileCommand.cxx
@@ -28,10 +28,10 @@ bool cmWhileFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff,
                                                cmExecutionStatus& inStatus)
 {
   // at end of for each execute recorded commands
-  if (!cmSystemTools::Strucmp(lff.Name.c_str(), "while")) {
+  if (lff.Name.Lower == "while") {
     // record the number of while commands past this one
     this->Depth++;
-  } else if (!cmSystemTools::Strucmp(lff.Name.c_str(), "endwhile")) {
+  } else if (lff.Name.Lower == "endwhile") {
     // if this is the endwhile for this while loop then execute
     if (!this->Depth) {
       // Remove the function blocker for this scope or bail.
@@ -117,7 +117,7 @@ bool cmWhileFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff,
 bool cmWhileFunctionBlocker::ShouldRemove(const cmListFileFunction& lff,
                                           cmMakefile&)
 {
-  if (!cmSystemTools::Strucmp(lff.Name.c_str(), "endwhile")) {
+  if (lff.Name.Lower == "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) {
diff --git a/Source/cmWorkingDirectory.cxx b/Source/cmWorkingDirectory.cxx
index 99c9ba86a..816f1044c 100644
--- a/Source/cmWorkingDirectory.cxx
+++ b/Source/cmWorkingDirectory.cxx
@@ -4,10 +4,12 @@
 
 #include "cmSystemTools.h"
 
+#include <cerrno>
+
 cmWorkingDirectory::cmWorkingDirectory(std::string const& newdir)
 {
   this->OldDir = cmSystemTools::GetCurrentWorkingDirectory();
-  cmSystemTools::ChangeDirectory(newdir);
+  this->SetDirectory(newdir);
 }
 
 cmWorkingDirectory::~cmWorkingDirectory()
@@ -15,10 +17,20 @@ cmWorkingDirectory::~cmWorkingDirectory()
   this->Pop();
 }
 
+bool cmWorkingDirectory::SetDirectory(std::string const& newdir)
+{
+  if (cmSystemTools::ChangeDirectory(newdir) == 0) {
+    this->ResultCode = 0;
+    return true;
+  }
+  this->ResultCode = errno;
+  return false;
+}
+
 void cmWorkingDirectory::Pop()
 {
   if (!this->OldDir.empty()) {
-    cmSystemTools::ChangeDirectory(this->OldDir);
+    this->SetDirectory(this->OldDir);
     this->OldDir.clear();
   }
 }
diff --git a/Source/cmWorkingDirectory.h b/Source/cmWorkingDirectory.h
index aff926755..1f18ce7a3 100644
--- a/Source/cmWorkingDirectory.h
+++ b/Source/cmWorkingDirectory.h
@@ -9,6 +9,12 @@
 
 /** \class cmWorkingDirectory
  * \brief An RAII class to manipulate the working directory.
+ *
+ * The current working directory is set to the location given to the
+ * constructor. The working directory can be changed again as needed
+ * by calling SetDirectory(). When the object is destroyed, the destructor
+ * will restore the working directory to what it was when the object was
+ * created, regardless of any calls to SetDirectory() in the meantime.
  */
 class cmWorkingDirectory
 {
@@ -16,10 +22,21 @@ public:
   cmWorkingDirectory(std::string const& newdir);
   ~cmWorkingDirectory();
 
+  bool SetDirectory(std::string const& newdir);
   void Pop();
+  bool Failed() const { return ResultCode != 0; }
+
+  /** \return 0 if the last attempt to set the working directory was
+   *          successful. If it failed, the value returned will be the
+   *          \c errno value associated with the failure. A description
+   *          of the error code can be obtained by passing the result
+   *          to \c std::strerror().
+   */
+  int GetLastResult() const { return ResultCode; }
 
 private:
   std::string OldDir;
+  int ResultCode;
 };
 
 #endif
diff --git a/Source/cmWriteFileCommand.cxx b/Source/cmWriteFileCommand.cxx
index 3464a1b30..d3d2db09a 100644
--- a/Source/cmWriteFileCommand.cxx
+++ b/Source/cmWriteFileCommand.cxx
@@ -54,7 +54,7 @@ bool cmWriteFileCommand::InitialPass(std::vector<std::string> const& args,
 #else
                                   mode | S_IWUSR | S_IWGRP
 #endif
-                                  );
+    );
   }
   // If GetPermissions fails, pretend like it is ok. File open will fail if
   // the file is not writable
diff --git a/Source/cmXMLWriter.cxx b/Source/cmXMLWriter.cxx
index 3cbc70dbd..9d2a3c454 100644
--- a/Source/cmXMLWriter.cxx
+++ b/Source/cmXMLWriter.cxx
@@ -9,6 +9,7 @@ cmXMLWriter::cmXMLWriter(std::ostream& output, std::size_t level)
   : Output(output)
   , IndentationElement(1, '\t')
   , Level(level)
+  , Indent(0)
   , ElementOpen(false)
   , BreakAttrib(false)
   , IsContent(false)
@@ -17,7 +18,7 @@ cmXMLWriter::cmXMLWriter(std::ostream& output, std::size_t level)
 
 cmXMLWriter::~cmXMLWriter()
 {
-  assert(this->Elements.empty());
+  assert(this->Indent == 0);
 }
 
 void cmXMLWriter::StartDocument(const char* encoding)
@@ -27,27 +28,29 @@ void cmXMLWriter::StartDocument(const char* encoding)
 
 void cmXMLWriter::EndDocument()
 {
-  assert(this->Elements.empty());
+  assert(this->Indent == 0);
   this->Output << '\n';
 }
 
 void cmXMLWriter::StartElement(std::string const& name)
 {
   this->CloseStartElement();
-  this->ConditionalLineBreak(!this->IsContent, this->Elements.size());
+  this->ConditionalLineBreak(!this->IsContent);
   this->Output << '<' << name;
   this->Elements.push(name);
+  ++this->Indent;
   this->ElementOpen = true;
   this->BreakAttrib = false;
 }
 
 void cmXMLWriter::EndElement()
 {
-  assert(!this->Elements.empty());
+  assert(this->Indent > 0);
+  --this->Indent;
   if (this->ElementOpen) {
     this->Output << "/>";
   } else {
-    this->ConditionalLineBreak(!this->IsContent, this->Elements.size() - 1);
+    this->ConditionalLineBreak(!this->IsContent);
     this->IsContent = false;
     this->Output << "</" << this->Elements.top() << '>';
   }
@@ -58,7 +61,7 @@ void cmXMLWriter::EndElement()
 void cmXMLWriter::Element(const char* name)
 {
   this->CloseStartElement();
-  this->ConditionalLineBreak(!this->IsContent, this->Elements.size());
+  this->ConditionalLineBreak(!this->IsContent);
   this->Output << '<' << name << "/>";
 }
 
@@ -70,7 +73,7 @@ void cmXMLWriter::BreakAttributes()
 void cmXMLWriter::Comment(const char* comment)
 {
   this->CloseStartElement();
-  this->ConditionalLineBreak(!this->IsContent, this->Elements.size());
+  this->ConditionalLineBreak(!this->IsContent);
   this->Output << "<!-- " << comment << " -->";
 }
 
@@ -83,14 +86,14 @@ void cmXMLWriter::CData(std::string const& data)
 void cmXMLWriter::Doctype(const char* doctype)
 {
   this->CloseStartElement();
-  this->ConditionalLineBreak(!this->IsContent, this->Elements.size());
+  this->ConditionalLineBreak(!this->IsContent);
   this->Output << "<!DOCTYPE " << doctype << ">";
 }
 
 void cmXMLWriter::ProcessingInstruction(const char* target, const char* data)
 {
   this->CloseStartElement();
-  this->ConditionalLineBreak(!this->IsContent, this->Elements.size());
+  this->ConditionalLineBreak(!this->IsContent);
   this->Output << "<?" << target << ' ' << data << "?>";
 }
 
@@ -106,11 +109,11 @@ void cmXMLWriter::SetIndentationElement(std::string const& element)
   this->IndentationElement = element;
 }
 
-void cmXMLWriter::ConditionalLineBreak(bool condition, std::size_t indent)
+void cmXMLWriter::ConditionalLineBreak(bool condition)
 {
   if (condition) {
     this->Output << '\n';
-    for (std::size_t i = 0; i < indent + this->Level; ++i) {
+    for (std::size_t i = 0; i < this->Indent + this->Level; ++i) {
       this->Output << this->IndentationElement;
     }
   }
@@ -119,7 +122,7 @@ void cmXMLWriter::ConditionalLineBreak(bool condition, std::size_t indent)
 void cmXMLWriter::PreAttribute()
 {
   assert(this->ElementOpen);
-  this->ConditionalLineBreak(this->BreakAttrib, this->Elements.size());
+  this->ConditionalLineBreak(this->BreakAttrib);
   if (!this->BreakAttrib) {
     this->Output << ' ';
   }
@@ -134,7 +137,7 @@ void cmXMLWriter::PreContent()
 void cmXMLWriter::CloseStartElement()
 {
   if (this->ElementOpen) {
-    this->ConditionalLineBreak(this->BreakAttrib, this->Elements.size());
+    this->ConditionalLineBreak(this->BreakAttrib);
     this->Output << '>';
     this->ElementOpen = false;
   }
diff --git a/Source/cmXMLWriter.h b/Source/cmXMLWriter.h
index 7bae21e2a..b08065409 100644
--- a/Source/cmXMLWriter.h
+++ b/Source/cmXMLWriter.h
@@ -67,7 +67,7 @@ public:
   void SetIndentationElement(std::string const& element);
 
 private:
-  void ConditionalLineBreak(bool condition, std::size_t indent);
+  void ConditionalLineBreak(bool condition);
 
   void PreAttribute();
   void PreContent();
@@ -128,9 +128,69 @@ private:
   std::stack<std::string, std::vector<std::string>> Elements;
   std::string IndentationElement;
   std::size_t Level;
+  std::size_t Indent;
   bool ElementOpen;
   bool BreakAttrib;
   bool IsContent;
 };
 
+class cmXMLElement; // IWYU pragma: keep
+
+class cmXMLDocument
+{
+public:
+  cmXMLDocument(cmXMLWriter& xml)
+    : xmlwr(xml)
+  {
+    xmlwr.StartDocument();
+  }
+  ~cmXMLDocument() { xmlwr.EndDocument(); }
+
+private:
+  friend class cmXMLElement;
+  cmXMLWriter& xmlwr;
+};
+
+class cmXMLElement
+{
+public:
+  cmXMLElement(cmXMLWriter& xml, const char* tag)
+    : xmlwr(xml)
+  {
+    xmlwr.StartElement(tag);
+  }
+  cmXMLElement(cmXMLElement& par, const char* tag)
+    : xmlwr(par.xmlwr)
+  {
+    xmlwr.StartElement(tag);
+  }
+  cmXMLElement(cmXMLDocument& doc, const char* tag)
+    : xmlwr(doc.xmlwr)
+  {
+    xmlwr.StartElement(tag);
+  }
+  ~cmXMLElement() { xmlwr.EndElement(); }
+
+  template <typename T>
+  cmXMLElement& Attribute(const char* name, T const& value)
+  {
+    xmlwr.Attribute(name, value);
+    return *this;
+  }
+  template <typename T>
+  void Content(T const& content)
+  {
+    xmlwr.Content(content);
+  }
+  template <typename T>
+  void Element(std::string const& name, T const& value)
+  {
+    xmlwr.Element(name, value);
+  }
+  void Comment(const char* comment) { xmlwr.Comment(comment); }
+
+private:
+  cmXMLWriter& xmlwr;
+};
+
 #endif
diff --git a/Source/cm_codecvt.cxx b/Source/cm_codecvt.cxx
index 670585172..9519f9155 100644
--- a/Source/cm_codecvt.cxx
+++ b/Source/cm_codecvt.cxx
@@ -3,11 +3,11 @@
 #include "cm_codecvt.hxx"
 
 #if defined(_WIN32)
-#include <assert.h>
-#include <string.h>
-#include <windows.h>
-#undef max
-#include "cmsys/Encoding.hxx"
+#  include <assert.h>
+#  include <string.h>
+#  include <windows.h>
+#  undef max
+#  include "cmsys/Encoding.hxx"
 #endif
 
 #if defined(_WIN32)
diff --git a/Source/cm_codecvt.hxx b/Source/cm_codecvt.hxx
index 3a5606b3d..2df39614c 100644
--- a/Source/cm_codecvt.hxx
+++ b/Source/cm_codecvt.hxx
@@ -52,13 +52,13 @@ private:
   };
 
   bool m_noconv;
-#if defined(_WIN32)
+#  if defined(_WIN32)
   unsigned int m_codepage;
   result Decode(mbstate_t& state, int need, const char*& from_next,
                 char*& to_next, char* to_end) const;
   result DecodePartial(mbstate_t& state, char*& to_next, char* to_end) const;
   void BufferPartial(mbstate_t& state, int need, const char*& from_next) const;
-#endif
+#  endif
 
 #endif
 };
diff --git a/Source/cmake.cxx b/Source/cmake.cxx
index 562072302..6edaa7468 100644
--- a/Source/cmake.cxx
+++ b/Source/cmake.cxx
@@ -28,83 +28,82 @@
 #include "cm_sys_stat.h"
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
-#include "cm_jsoncpp_writer.h"
+#  include "cm_jsoncpp_writer.h"
 
-#include "cmGraphVizWriter.h"
-#include "cmVariableWatch.h"
-#include <unordered_map>
+#  include "cmGraphVizWriter.h"
+#  include "cmVariableWatch.h"
+#  include <unordered_map>
 #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 "cmGlobalVisualStudio15Generator.h"
-#include "cmGlobalVisualStudio8Generator.h"
-#include "cmGlobalVisualStudio9Generator.h"
-#include "cmVSSetupHelper.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 "cmGlobalVisualStudio15Generator.h"
+#    include "cmGlobalVisualStudio9Generator.h"
+#    include "cmVSSetupHelper.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_ECLIPSE
-#include "cmExtraEclipseCDT4Generator.h"
+#  include "cmExtraEclipseCDT4Generator.h"
 #endif
 
 #if defined(__APPLE__)
-#if defined(CMAKE_BUILD_WITH_CMAKE)
-#include "cmGlobalXCodeGenerator.h"
+#  if defined(CMAKE_BUILD_WITH_CMAKE)
+#    include "cmGlobalXCodeGenerator.h"
 
-#define CMAKE_USE_XCODE 1
-#endif
-#include <sys/resource.h>
-#include <sys/time.h>
+#    define CMAKE_USE_XCODE 1
+#  endif
+#  include <sys/resource.h>
+#  include <sys/time.h>
 #endif
 
 #include "cmsys/FStream.hxx"
 #include "cmsys/Glob.hxx"
 #include "cmsys/RegularExpression.hxx"
 #include <algorithm>
+#include <cstring>
 #include <iostream>
 #include <iterator>
 #include <memory> // IWYU pragma: keep
 #include <sstream>
 #include <stdio.h>
 #include <stdlib.h>
-#include <string.h>
 #include <utility>
 
 namespace {
@@ -892,9 +891,9 @@ void cmake::AddDefaultExtraGenerators()
   this->ExtraGenerators.push_back(cmExtraSublimeTextGenerator::GetFactory());
   this->ExtraGenerators.push_back(cmExtraKateGenerator::GetFactory());
 
-#ifdef CMAKE_USE_ECLIPSE
+#  ifdef CMAKE_USE_ECLIPSE
   this->ExtraGenerators.push_back(cmExtraEclipseCDT4Generator::GetFactory());
-#endif
+#  endif
 
 #endif
 }
@@ -1434,6 +1433,7 @@ int cmake::ActualConfigure()
 
   // only save the cache if there were no fatal errors
   if (this->GetWorkingMode() == NORMAL_MODE) {
+    this->State->SaveVerificationScript(this->GetHomeOutputDirectory());
     this->SaveCache(this->GetHomeOutputDirectory());
   }
   if (cmSystemTools::GetErrorOccuredFlag()) {
@@ -1464,8 +1464,7 @@ void cmake::CreateDefaultGlobalGenerator()
     { "12.0", "Visual Studio 12 2013" }, //
     { "11.0", "Visual Studio 11 2012" }, //
     { "10.0", "Visual Studio 10 2010" }, //
-    { "9.0", "Visual Studio 9 2008" },   //
-    { "8.0", "Visual Studio 8 2005" }
+    { "9.0", "Visual Studio 9 2008" }
   };
   static const char* const vsEntries[] = {
     "\\Setup\\VC;ProductDir", //
@@ -1649,6 +1648,33 @@ void cmake::AddCacheEntry(const std::string& key, const char* value,
   this->UnwatchUnusedCli(key);
 }
 
+bool cmake::DoWriteGlobVerifyTarget() const
+{
+  return this->State->DoWriteGlobVerifyTarget();
+}
+
+std::string const& cmake::GetGlobVerifyScript() const
+{
+  return this->State->GetGlobVerifyScript();
+}
+
+std::string const& cmake::GetGlobVerifyStamp() const
+{
+  return this->State->GetGlobVerifyStamp();
+}
+
+void cmake::AddGlobCacheEntry(bool recurse, bool listDirectories,
+                              bool followSymlinks, const std::string& relative,
+                              const std::string& expression,
+                              const std::vector<std::string>& files,
+                              const std::string& variable,
+                              cmListFileBacktrace const& backtrace)
+{
+  this->State->AddGlobCacheEntry(recurse, listDirectories, followSymlinks,
+                                 relative, expression, files, variable,
+                                 backtrace);
+}
+
 std::string cmake::StripExtension(const std::string& file) const
 {
   auto dotpos = file.rfind('.');
@@ -1682,19 +1708,18 @@ void cmake::AddProjectCommands()
 void cmake::AddDefaultGenerators()
 {
 #if defined(_WIN32) && !defined(__CYGWIN__)
-#if !defined(CMAKE_BOOT_MINGW)
+#  if !defined(CMAKE_BOOT_MINGW)
   this->Generators.push_back(cmGlobalVisualStudio15Generator::NewFactory());
   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(cmGlobalBorlandMakefileGenerator::NewFactory());
   this->Generators.push_back(cmGlobalNMakeMakefileGenerator::NewFactory());
   this->Generators.push_back(cmGlobalJOMMakefileGenerator::NewFactory());
   this->Generators.push_back(cmGlobalGhsMultiGenerator::NewFactory());
-#endif
+#  endif
   this->Generators.push_back(cmGlobalMSYSMakefileGenerator::NewFactory());
   this->Generators.push_back(cmGlobalMinGWMakefileGenerator::NewFactory());
 #endif
@@ -2209,6 +2234,15 @@ int cmake::GetSystemInformation(std::vector<std::string>& args)
   {
     // now run cmake on the CMakeLists file
     cmWorkingDirectory workdir(destPath);
+    if (workdir.Failed()) {
+      // We created the directory and we were able to copy the CMakeLists.txt
+      // file to it, so we wouldn't expect to get here unless the default
+      // permissions are questionable or some other process has deleted the
+      // directory
+      std::cerr << "Failed to change to directory " << destPath << " : "
+                << std::strerror(workdir.GetLastResult()) << std::endl;
+      return 1;
+    }
     std::vector<std::string> args2;
     args2.push_back(args[0]);
     args2.push_back(destPath);
@@ -2364,7 +2398,7 @@ cmMessenger* cmake::GetMessenger() const
   return this->Messenger;
 }
 
-int cmake::Build(const std::string& dir, const std::string& target,
+int cmake::Build(int jobs, const std::string& dir, const std::string& target,
                  const std::string& config,
                  const std::vector<std::string>& nativeOptions, bool clean)
 {
@@ -2387,17 +2421,17 @@ int cmake::Build(const std::string& dir, const std::string& target,
     std::cerr << "Error: could not find CMAKE_GENERATOR in Cache\n";
     return 1;
   }
-  std::unique_ptr<cmGlobalGenerator> gen(
-    this->CreateGlobalGenerator(cachedGenerator));
-  if (!gen.get()) {
+  cmGlobalGenerator* gen = this->CreateGlobalGenerator(cachedGenerator);
+  if (!gen) {
     std::cerr << "Error: could create CMAKE_GENERATOR \"" << cachedGenerator
               << "\"\n";
     return 1;
   }
+  this->SetGlobalGenerator(gen);
   const char* cachedGeneratorInstance =
     this->State->GetCacheEntryValue("CMAKE_GENERATOR_INSTANCE");
   if (cachedGeneratorInstance) {
-    cmMakefile mf(gen.get(), this->GetCurrentSnapshot());
+    cmMakefile mf(gen, this->GetCurrentSnapshot());
     if (!gen->SetGeneratorInstance(cachedGeneratorInstance, &mf)) {
       return 1;
     }
@@ -2425,44 +2459,58 @@ int cmake::Build(const std::string& dir, const std::string& target,
   // to limitations of the underlying build system.
   std::string const stampList = cachePath + "/" +
     GetCMakeFilesDirectoryPostSlash() +
-    cmGlobalVisualStudio8Generator::GetGenerateStampList();
+    cmGlobalVisualStudio9Generator::GetGenerateStampList();
 
   // Note that the stampList file only exists for VS generators.
-  if (cmSystemTools::FileExists(stampList) &&
-      !cmakeCheckStampList(stampList.c_str(), false)) {
-
-    // Correctly initialize the home (=source) and home output (=binary)
-    // directories, which is required for running the generation step.
-    std::string homeOrig = this->GetHomeDirectory();
-    std::string homeOutputOrig = this->GetHomeOutputDirectory();
-    this->SetDirectoriesFromFile(cachePath.c_str());
+  if (cmSystemTools::FileExists(stampList)) {
 
+    // Check if running for Visual Studio 9 - we need to explicitly run
+    // the glob verification script before starting the build
     this->AddScriptingCommands();
-    this->AddProjectCommands();
-
-    int ret = this->Configure();
-    if (ret) {
-      cmSystemTools::Message("CMake Configure step failed.  "
-                             "Build files cannot be regenerated correctly.");
-      return ret;
-    }
-    ret = this->Generate();
-    if (ret) {
-      cmSystemTools::Message("CMake Generate step failed.  "
-                             "Build files cannot be regenerated correctly.");
-      return ret;
+    if (this->GlobalGenerator->MatchesGeneratorName("Visual Studio 9 2008")) {
+      std::string const globVerifyScript = cachePath + "/" +
+        GetCMakeFilesDirectoryPostSlash() + "VerifyGlobs.cmake";
+      if (cmSystemTools::FileExists(globVerifyScript)) {
+        std::vector<std::string> args;
+        this->ReadListFile(args, globVerifyScript.c_str());
+      }
     }
-    std::string message = "Build files have been written to: ";
-    message += this->GetHomeOutputDirectory();
-    this->UpdateProgress(message.c_str(), -1);
 
-    // Restore the previously set directories to their original value.
-    this->SetHomeDirectory(homeOrig);
-    this->SetHomeOutputDirectory(homeOutputOrig);
+    if (!cmakeCheckStampList(stampList.c_str(), false)) {
+      // Correctly initialize the home (=source) and home output (=binary)
+      // directories, which is required for running the generation step.
+      std::string homeOrig = this->GetHomeDirectory();
+      std::string homeOutputOrig = this->GetHomeOutputDirectory();
+      this->SetDirectoriesFromFile(cachePath.c_str());
+
+      this->AddProjectCommands();
+
+      int ret = this->Configure();
+      if (ret) {
+        cmSystemTools::Message("CMake Configure step failed.  "
+                               "Build files cannot be regenerated correctly.");
+        return ret;
+      }
+      ret = this->Generate();
+      if (ret) {
+        cmSystemTools::Message("CMake Generate step failed.  "
+                               "Build files cannot be regenerated correctly.");
+        return ret;
+      }
+      std::string message = "Build files have been written to: ";
+      message += this->GetHomeOutputDirectory();
+      this->UpdateProgress(message.c_str(), -1);
+
+      // Restore the previously set directories to their original value.
+      this->SetHomeDirectory(homeOrig);
+      this->SetHomeOutputDirectory(homeOutputOrig);
+    }
   }
 #endif
 
-  return gen->Build("", dir, projName, target, output, "", config, clean,
+  gen->PrintBuildCommandAdvice(std::cerr, jobs);
+
+  return gen->Build(jobs, "", dir, projName, target, output, "", config, clean,
                     false, verbose, cmDuration::zero(),
                     cmSystemTools::OUTPUT_PASSTHROUGH, nativeOptions);
 }
diff --git a/Source/cmake.h b/Source/cmake.h
index 1ac549b90..86e06df45 100644
--- a/Source/cmake.h
+++ b/Source/cmake.h
@@ -17,7 +17,7 @@
 #include "cmStateTypes.h"
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
-#include "cm_jsoncpp_value.h"
+#  include "cm_jsoncpp_value.h"
 #endif
 
 class cmExternalMakefileProjectGeneratorFactory;
@@ -119,6 +119,9 @@ public:
 
   typedef std::map<std::string, cmInstalledFile> InstalledFilesMap;
 
+  static const int NO_BUILD_PARALLEL_LEVEL = -1;
+  static const int DEFAULT_BUILD_PARALLEL_LEVEL = 0;
+
   /// Default constructor
   cmake(Role role);
   /// Destructor
@@ -255,6 +258,16 @@ public:
   void AddCacheEntry(const std::string& key, const char* value,
                      const char* helpString, int type);
 
+  bool DoWriteGlobVerifyTarget() const;
+  std::string const& GetGlobVerifyScript() const;
+  std::string const& GetGlobVerifyStamp() const;
+  void AddGlobCacheEntry(bool recurse, bool listDirectories,
+                         bool followSymlinks, const std::string& relative,
+                         const std::string& expression,
+                         const std::vector<std::string>& files,
+                         const std::string& variable,
+                         cmListFileBacktrace const& bt);
+
   /**
    * Get the system information and write it to the file specified
    */
@@ -420,7 +433,7 @@ public:
     cmListFileBacktrace const& backtrace = cmListFileBacktrace()) const;
 
   ///! run the --build option
-  int Build(const std::string& dir, const std::string& target,
+  int Build(int jobs, const std::string& dir, const std::string& target,
             const std::string& config,
             const std::vector<std::string>& nativeOptions, bool clean);
 
@@ -540,7 +553,7 @@ private:
 
 #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." },           \
+    { "-D <var>[:<type>]=<value>", "Create or update a cmake cache entry." }, \
     { "-U <globbing_expr>", "Remove matching entries from CMake cache." },    \
     { "-G <generator-name>", "Specify a build system generator." },           \
     { "-T <toolset-name>",                                                    \
@@ -553,11 +566,13 @@ private:
     { "-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." },                                      \
+    { "-Werror=deprecated",                                                   \
+      "Make deprecated macro and function warnings "                          \
+      "errors." },                                                            \
   {                                                                           \
-    "-Wno-error=deprecated", "Make deprecated macro and function warnings "   \
-                             "not errors."                                    \
+    "-Wno-error=deprecated",                                                  \
+      "Make deprecated macro and function warnings "                          \
+      "not errors."                                                           \
   }
 
 #define FOR_EACH_C_FEATURE(F)                                                 \
@@ -574,6 +589,7 @@ private:
   F(cxx_std_11)                                                               \
   F(cxx_std_14)                                                               \
   F(cxx_std_17)                                                               \
+  F(cxx_std_20)                                                               \
   F(cxx_aggregate_default_initializers)                                       \
   F(cxx_alias_templates)                                                      \
   F(cxx_alignas)                                                              \
diff --git a/Source/cmakemain.cxx b/Source/cmakemain.cxx
index b185a1bc4..e3d94f66e 100644
--- a/Source/cmakemain.cxx
+++ b/Source/cmakemain.cxx
@@ -1,7 +1,6 @@
 /* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
    file Copyright.txt or https://cmake.org/licensing for details.  */
 
-#include "cmake.h"
 #include "cmAlgorithms.h"
 #include "cmDocumentationEntry.h"
 #include "cmGlobalGenerator.h"
@@ -9,19 +8,22 @@
 #include "cmState.h"
 #include "cmStateTypes.h"
 #include "cmSystemTools.h"
+#include "cmake.h"
 #include "cmcmd.h"
 
 #ifdef CMAKE_BUILD_WITH_CMAKE
-#include "cmDocumentation.h"
-#include "cmDynamicLoader.h"
+#  include "cmDocumentation.h"
+#  include "cmDynamicLoader.h"
 #endif
 
 #include "cm_uv.h"
 
 #include "cmsys/Encoding.hxx"
 #if defined(_WIN32) && defined(CMAKE_BUILD_WITH_CMAKE)
-#include "cmsys/ConsoleBuf.hxx"
+#  include "cmsys/ConsoleBuf.hxx"
 #endif
+
+#include <ctype.h>
 #include <iostream>
 #include <string.h>
 #include <string>
@@ -34,11 +36,13 @@ static const char* cmDocumentationName[][2] = {
 };
 
 static const char* cmDocumentationUsage[][2] = {
-  { nullptr, "  cmake [options] <path-to-source>\n"
-             "  cmake [options] <path-to-existing-build>" },
-  { nullptr, "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." },
+  { nullptr,
+    "  cmake [options] <path-to-source>\n"
+    "  cmake [options] <path-to-existing-build>" },
+  { nullptr,
+    "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." },
   { nullptr, nullptr }
 };
 
@@ -47,15 +51,23 @@ static const char* cmDocumentationUsageNote[][2] = {
   { nullptr, nullptr }
 };
 
-#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"
+#  define CMAKE_BUILD_OPTIONS                                                 \
+    "  <dir>          = Project binary directory to be built.\n"              \
+    "  -j [<jobs>] --parallel [<jobs>] = Build in parallel using\n"           \
+    "                   the given number of jobs. If <jobs> is omitted\n"     \
+    "                   the native build tool's default number is used.\n"    \
+    "                   The CMAKE_BUILD_PARALLEL_LEVEL environment "          \
+    "variable\n"                                                              \
+    "                   specifies a default parallel level when this "        \
+    "option\n"                                                                \
+    "                   is not given.\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] = {
   CMAKE_STANDARD_OPTIONS_TABLE,
@@ -66,11 +78,13 @@ static const char* cmDocumentationOptions[][2] = {
   { "-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." },
+  { "--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-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." },
@@ -79,8 +93,9 @@ static const char* cmDocumentationOptions[][2] = {
   { "--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." },
+  { "--check-system-vars",
+    "Find problems with variable usage in system "
+    "files." },
   { nullptr, nullptr }
 };
 
@@ -338,6 +353,7 @@ static int do_build(int ac, char const* const* av)
   std::cerr << "This cmake does not support --build\n";
   return -1;
 #else
+  int jobs = cmake::NO_BUILD_PARALLEL_LEVEL;
   std::string target;
   std::string config = "Debug";
   std::string dir;
@@ -348,6 +364,7 @@ static int do_build(int ac, char const* const* av)
   enum Doing
   {
     DoingNone,
+    DoingJobs,
     DoingDir,
     DoingTarget,
     DoingConfig,
@@ -357,6 +374,13 @@ static int do_build(int ac, char const* const* av)
   for (int i = 2; i < ac; ++i) {
     if (doing == DoingNative) {
       nativeOptions.push_back(av[i]);
+    } else if ((strcmp(av[i], "-j") == 0) ||
+               (strcmp(av[i], "--parallel") == 0)) {
+      jobs = cmake::DEFAULT_BUILD_PARALLEL_LEVEL;
+      /* does the next argument start with a number? */
+      if ((i + 1 < ac) && (isdigit(*av[i + 1]))) {
+        doing = DoingJobs;
+      }
     } else if (strcmp(av[i], "--target") == 0) {
       if (!hasTarget) {
         doing = DoingTarget;
@@ -377,6 +401,18 @@ static int do_build(int ac, char const* const* av)
       doing = DoingNative;
     } else {
       switch (doing) {
+        case DoingJobs: {
+          unsigned long numJobs = 0;
+          if (cmSystemTools::StringToULong(av[i], &numJobs)) {
+            jobs = int(numJobs);
+            doing = DoingNone;
+          } else {
+            std::cerr << "'" << av[i - 1] << "' invalid number '" << av[i]
+                      << "' given.\n\n";
+            dir.clear();
+            break;
+          }
+        } break;
         case DoingDir:
           dir = cmSystemTools::CollapseFullPath(av[i]);
           doing = DoingNone;
@@ -396,6 +432,25 @@ static int do_build(int ac, char const* const* av)
       }
     }
   }
+
+  if (jobs == cmake::NO_BUILD_PARALLEL_LEVEL) {
+    std::string parallel;
+    if (cmSystemTools::GetEnv("CMAKE_BUILD_PARALLEL_LEVEL", parallel)) {
+      if (parallel.empty()) {
+        jobs = cmake::DEFAULT_BUILD_PARALLEL_LEVEL;
+      } else {
+        unsigned long numJobs = 0;
+        if (cmSystemTools::StringToULong(parallel.c_str(), &numJobs)) {
+          jobs = int(numJobs);
+        } else {
+          std::cerr << "'CMAKE_BUILD_PARALLEL_LEVEL' environment variable\n"
+                    << "invalid number '" << parallel << "' given.\n\n";
+          dir.clear();
+        }
+      }
+    }
+  }
+
   if (dir.empty()) {
     /* clang-format off */
     std::cerr <<
@@ -410,7 +465,7 @@ static int do_build(int ac, char const* const* av)
   cmake cm(cmake::RoleInternal);
   cmSystemTools::SetMessageCallback(cmakemainMessageCallback, &cm);
   cm.SetProgressCallback(cmakemainProgressCallback, &cm);
-  return cm.Build(dir, target, config, nativeOptions, clean);
+  return cm.Build(jobs, dir, target, config, nativeOptions, clean);
 #endif
 }
 
diff --git a/Source/cmcmd.cxx b/Source/cmcmd.cxx
index 0988c3c04..0a75e77d2 100644
--- a/Source/cmcmd.cxx
+++ b/Source/cmcmd.cxx
@@ -17,17 +17,17 @@
 #include "cmake.h"
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
-#include "cmDependsFortran.h" // For -E cmake_copy_f90_mod callback.
-#include "cmServer.h"
-#include "cmServerConnection.h"
+#  include "cmDependsFortran.h" // For -E cmake_copy_f90_mod callback.
+#  include "cmServer.h"
+#  include "cmServerConnection.h"
 #endif
 
 #if defined(CMAKE_BUILD_WITH_CMAKE) && defined(_WIN32)
-#include "bindexplib.h"
+#  include "bindexplib.h"
 #endif
 
 #if defined(CMAKE_BUILD_WITH_CMAKE) && defined(_WIN32) && !defined(__CYGWIN__)
-#include "cmVisualStudioWCEPlatformParser.h"
+#  include "cmVisualStudioWCEPlatformParser.h"
 #endif
 
 #include "cmsys/Directory.hxx"
@@ -359,7 +359,8 @@ struct CoCompileJob
 int cmcmd::HandleCoCompileCommands(std::vector<std::string>& args)
 {
   std::vector<CoCompileJob> jobs;
-  std::string sourceFile; // store --source=
+  std::string sourceFile;             // store --source=
+  std::vector<std::string> launchers; // store --launcher=
 
   // Default is to run the original command found after -- if the option
   // does not need to do that, it should be specified here, currently only
@@ -390,15 +391,17 @@ int cmcmd::HandleCoCompileCommands(std::vector<std::string>& args)
           }
         }
       }
-      if (cmHasLiteralPrefix(arg, "--source=")) {
-        sourceFile = arg.substr(9);
-        optionFound = true;
-      }
-      // if it was not a co-compiler or --source then error
       if (!optionFound) {
-        std::cerr << "__run_co_compile given unknown argument: " << arg
-                  << "\n";
-        return 1;
+        if (cmHasLiteralPrefix(arg, "--source=")) {
+          sourceFile = arg.substr(9);
+        } else if (cmHasLiteralPrefix(arg, "--launcher=")) {
+          cmSystemTools::ExpandListArgument(arg.substr(11), launchers, true);
+        } else {
+          // if it was not a co-compiler or --source/--launcher then error
+          std::cerr << "__run_co_compile given unknown argument: " << arg
+                    << "\n";
+          return 1;
+        }
       }
     } else { // if not doing_options then push to orig_cmd
       orig_cmd.push_back(arg);
@@ -436,6 +439,11 @@ int cmcmd::HandleCoCompileCommands(std::vector<std::string>& args)
     return 0;
   }
 
+  // Prepend launcher argument(s), if any
+  if (!launchers.empty()) {
+    orig_cmd.insert(orig_cmd.begin(), launchers.begin(), launchers.end());
+  }
+
   // Now run the real compiler command and return its result value
   int ret;
   if (!cmSystemTools::RunSingleCommand(orig_cmd, nullptr, nullptr, &ret,
@@ -689,8 +697,6 @@ int cmcmd::ExecuteCMakeCommand(std::vector<std::string>& args)
     // Touch file
     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)) {
           return 1;
         }
@@ -1769,8 +1775,9 @@ int cmVSLink::LinkIncremental()
     if (!fout) {
       return -1;
     }
-    fout << this->Type << " /* CREATEPROCESS_MANIFEST_RESOURCE_ID */ "
-                          "24 /* RT_MANIFEST */ \""
+    fout << this->Type
+         << " /* CREATEPROCESS_MANIFEST_RESOURCE_ID */ "
+            "24 /* RT_MANIFEST */ \""
          << absManifestFile << "\"";
   }
 
diff --git a/Source/ctest.cxx b/Source/ctest.cxx
index 0a6d1d25d..b338dea48 100644
--- a/Source/ctest.cxx
+++ b/Source/ctest.cxx
@@ -9,7 +9,7 @@
 
 #include "cmsys/Encoding.hxx"
 #if defined(_WIN32) && defined(CMAKE_BUILD_WITH_CMAKE)
-#include "cmsys/ConsoleBuf.hxx"
+#  include "cmsys/ConsoleBuf.hxx"
 #endif
 #include <iostream>
 #include <string.h>
@@ -30,60 +30,76 @@ static const char* cmDocumentationOptions[][2] = {
   { "-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" },
+  { "--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." },
+  { "-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." },
-  { "-FA <regex>, --fixture-exclude-any <regex>", "Do not automatically "
-                                                  "add any tests for "
-                                                  "fixtures matching "
-                                                  "regular expression." },
-  { "-FS <regex>, --fixture-exclude-setup <regex>", "Do not automatically "
-                                                    "add setup tests for "
-                                                    "fixtures matching "
-                                                    "regular expression." },
-  { "-FC <regex>, --fixture-exclude-cleanup <regex>", "Do not automatically "
-                                                      "add cleanup tests for "
-                                                      "fixtures matching "
-                                                      "regular expression." },
+  { "-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." },
+  { "-FA <regex>, --fixture-exclude-any <regex>",
+    "Do not automatically "
+    "add any tests for "
+    "fixtures matching "
+    "regular expression." },
+  { "-FS <regex>, --fixture-exclude-setup <regex>",
+    "Do not automatically "
+    "add setup tests for "
+    "fixtures matching "
+    "regular expression." },
+  { "-FC <regex>, --fixture-exclude-cleanup <regex>",
+    "Do not automatically "
+    "add cleanup tests for "
+    "fixtures 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" },
+  { "-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" },
+  { "-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" },
+  { "--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." },
-  { "--no-subproject-summary", "Disable timing summary information for "
-                               "subprojects." },
+  { "--no-subproject-summary",
+    "Disable timing summary information for "
+    "subprojects." },
   { "--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." },
@@ -161,7 +177,8 @@ int main(int argc, char const* const* argv)
       !(cmSystemTools::FileExists("CTestTestfile.cmake") ||
         cmSystemTools::FileExists("DartTestfile.txt"))) {
     if (argc == 1) {
-      cmCTestLog(&inst, ERROR_MESSAGE, "*********************************"
+      cmCTestLog(&inst, ERROR_MESSAGE,
+                 "*********************************"
                    << std::endl
                    << "No test configuration file found!" << std::endl
                    << "*********************************" << std::endl);
diff --git a/Source/kwsys/Base64.c b/Source/kwsys/Base64.c
index 99f008e59..bf876f2d5 100644
--- a/Source/kwsys/Base64.c
+++ b/Source/kwsys/Base64.c
@@ -6,7 +6,7 @@
 /* Work-around CMake dependency scanning limitation.  This must
    duplicate the above list of headers.  */
 #if 0
-#include "Base64.h.in"
+#  include "Base64.h.in"
 #endif
 
 static const unsigned char kwsysBase64EncodeTable[65] =
diff --git a/Source/kwsys/Base64.h.in b/Source/kwsys/Base64.h.in
index 35367574a..729f97297 100644
--- a/Source/kwsys/Base64.h.in
+++ b/Source/kwsys/Base64.h.in
@@ -12,17 +12,17 @@
    not visible to user code.  Use kwsysHeaderDump.pl to reproduce
    these macros after making changes to the interface.  */
 #if !defined(KWSYS_NAMESPACE)
-#define kwsys_ns(x) @KWSYS_NAMESPACE@##x
-#define kwsysEXPORT @KWSYS_NAMESPACE@_EXPORT
+#  define kwsys_ns(x) @KWSYS_NAMESPACE@##x
+#  define kwsysEXPORT @KWSYS_NAMESPACE@_EXPORT
 #endif
 #if !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
-#define kwsysBase64 kwsys_ns(Base64)
-#define kwsysBase64_Decode kwsys_ns(Base64_Decode)
-#define kwsysBase64_Decode3 kwsys_ns(Base64_Decode3)
-#define kwsysBase64_Encode kwsys_ns(Base64_Encode)
-#define kwsysBase64_Encode1 kwsys_ns(Base64_Encode1)
-#define kwsysBase64_Encode2 kwsys_ns(Base64_Encode2)
-#define kwsysBase64_Encode3 kwsys_ns(Base64_Encode3)
+#  define kwsysBase64 kwsys_ns(Base64)
+#  define kwsysBase64_Decode kwsys_ns(Base64_Decode)
+#  define kwsysBase64_Decode3 kwsys_ns(Base64_Decode3)
+#  define kwsysBase64_Encode kwsys_ns(Base64_Encode)
+#  define kwsysBase64_Encode1 kwsys_ns(Base64_Encode1)
+#  define kwsysBase64_Encode2 kwsys_ns(Base64_Encode2)
+#  define kwsysBase64_Encode3 kwsys_ns(Base64_Encode3)
 #endif
 
 #if defined(__cplusplus)
@@ -94,17 +94,17 @@ kwsysEXPORT size_t kwsysBase64_Decode(const unsigned char* input,
 /* If we are building a kwsys .c or .cxx file, let it use these macros.
    Otherwise, undefine them to keep the namespace clean.  */
 #if !defined(KWSYS_NAMESPACE)
-#undef kwsys_ns
-#undef kwsysEXPORT
-#if !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
-#undef kwsysBase64
-#undef kwsysBase64_Decode
-#undef kwsysBase64_Decode3
-#undef kwsysBase64_Encode
-#undef kwsysBase64_Encode1
-#undef kwsysBase64_Encode2
-#undef kwsysBase64_Encode3
-#endif
+#  undef kwsys_ns
+#  undef kwsysEXPORT
+#  if !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
+#    undef kwsysBase64
+#    undef kwsysBase64_Decode
+#    undef kwsysBase64_Decode3
+#    undef kwsysBase64_Encode
+#    undef kwsysBase64_Encode1
+#    undef kwsysBase64_Encode2
+#    undef kwsysBase64_Encode3
+#  endif
 #endif
 
 #endif
diff --git a/Source/kwsys/CMakeLists.txt b/Source/kwsys/CMakeLists.txt
index 4fc176b37..96088c8f6 100644
--- a/Source/kwsys/CMakeLists.txt
+++ b/Source/kwsys/CMakeLists.txt
@@ -196,6 +196,11 @@ IF(KWSYS_STANDALONE)
   ENDIF()
 ENDIF()
 
+# Choose default shared/static build if not specified.
+IF(NOT DEFINED KWSYS_BUILD_SHARED)
+  SET(KWSYS_BUILD_SHARED ${BUILD_SHARED_LIBS})
+ENDIF()
+
 # Include helper macros.
 INCLUDE(${CMAKE_CURRENT_SOURCE_DIR}/kwsysPlatformTests.cmake)
 INCLUDE(CheckTypeSize)
@@ -230,13 +235,14 @@ ENDIF()
 
 # Setup library install rules.
 SET(KWSYS_INSTALL_LIBRARY_RULE)
+SET(KWSYS_INSTALL_NAMELINK_RULE)
 IF(KWSYS_INSTALL_LIB_DIR)
   IF(KWSYS_INSTALL_EXPORT_NAME)
     LIST(APPEND KWSYS_INSTALL_LIBRARY_RULE EXPORT ${KWSYS_INSTALL_EXPORT_NAME})
   ENDIF()
   # Install the shared library to the lib directory.
   SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
-    LIBRARY DESTINATION ${KWSYS_INSTALL_LIB_DIR}
+    LIBRARY DESTINATION ${KWSYS_INSTALL_LIB_DIR} NAMELINK_SKIP
     )
   # Assign the shared library to the runtime component.
   IF(KWSYS_INSTALL_COMPONENT_NAME_RUNTIME)
@@ -244,6 +250,17 @@ IF(KWSYS_INSTALL_LIB_DIR)
       COMPONENT ${KWSYS_INSTALL_COMPONENT_NAME_RUNTIME}
       )
   ENDIF()
+  IF(KWSYS_BUILD_SHARED)
+    SET(KWSYS_INSTALL_NAMELINK_RULE ${KWSYS_INSTALL_NAMELINK_RULE}
+      LIBRARY DESTINATION ${KWSYS_INSTALL_LIB_DIR} NAMELINK_ONLY
+      )
+    # Assign the namelink to the development component.
+    IF(KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT)
+      SET(KWSYS_INSTALL_NAMELINK_RULE ${KWSYS_INSTALL_NAMELINK_RULE}
+        COMPONENT ${KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT}
+        )
+    ENDIF()
+  ENDIF()
 
   # Install the archive to the lib directory.
   SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
@@ -427,11 +444,6 @@ ELSE()
   SET(KWSYS_NAME_IS_KWSYS 0)
 ENDIF()
 
-# Choose default shared/static build if not specified.
-IF(KWSYS_BUILD_SHARED MATCHES "^KWSYS_BUILD_SHARED$")
-  SET(KWSYS_BUILD_SHARED ${BUILD_SHARED_LIBS})
-ENDIF()
-
 IF(KWSYS_BUILD_SHARED)
   SET(KWSYS_BUILD_SHARED 1)
   SET(KWSYS_LIBRARY_TYPE SHARED)
@@ -933,6 +945,9 @@ IF(KWSYS_C_SRCS OR KWSYS_CXX_SRCS)
   IF(KWSYS_INSTALL_LIBRARY_RULE)
     INSTALL(TARGETS ${KWSYS_TARGET_INSTALL} ${KWSYS_INSTALL_LIBRARY_RULE})
   ENDIF()
+  IF(KWSYS_INSTALL_NAMELINK_RULE)
+    INSTALL(TARGETS ${KWSYS_TARGET_INSTALL} ${KWSYS_INSTALL_NAMELINK_RULE})
+  ENDIF()
 ENDIF()
 
 # Add a C-only library if requested.
diff --git a/Source/kwsys/CONTRIBUTING.rst b/Source/kwsys/CONTRIBUTING.rst
index 70a313e05..32e7b83c5 100644
--- a/Source/kwsys/CONTRIBUTING.rst
+++ b/Source/kwsys/CONTRIBUTING.rst
@@ -27,7 +27,7 @@ copies of KWSys within dependent projects can be updated to get the changes.
 Code Style
 ==========
 
-We use `clang-format`_ version **3.8** to define our style for C++ code in
+We use `clang-format`_ version **6.0** to define our style for C++ code in
 the KWSys source tree.  See the `.clang-format`_ configuration file for
 our style settings.  Use the `clang-format.bash`_ script to format source
 code.  It automatically runs ``clang-format`` on the set of source files
diff --git a/Source/kwsys/CommandLineArguments.cxx b/Source/kwsys/CommandLineArguments.cxx
index a6387eaba..a97f7a836 100644
--- a/Source/kwsys/CommandLineArguments.cxx
+++ b/Source/kwsys/CommandLineArguments.cxx
@@ -9,9 +9,9 @@
 // Work-around CMake dependency scanning limitation.  This must
 // duplicate the above list of headers.
 #if 0
-#include "CommandLineArguments.hxx.in"
-#include "Configure.hxx.in"
-#include "String.hxx.in"
+#  include "CommandLineArguments.hxx.in"
+#  include "Configure.hxx.in"
+#  include "String.hxx.in"
 #endif
 
 #include <iostream>
@@ -25,18 +25,18 @@
 #include <string.h>
 
 #ifdef _MSC_VER
-#pragma warning(disable : 4786)
+#  pragma warning(disable : 4786)
 #endif
 
 #if defined(__sgi) && !defined(__GNUC__)
-#pragma set woff 1375 /* base class destructor not virtual */
+#  pragma set woff 1375 /* base class destructor not virtual */
 #endif
 
 #if 0
-#define CommandLineArguments_DEBUG(x)                                         \
-  std::cout << __LINE__ << " CLA: " << x << std::endl
+#  define CommandLineArguments_DEBUG(x)                                       \
+    std::cout << __LINE__ << " CLA: " << x << std::endl
 #else
-#define CommandLineArguments_DEBUG(x)
+#  define CommandLineArguments_DEBUG(x)
 #endif
 
 namespace KWSYS_NAMESPACE {
diff --git a/Source/kwsys/Configure.h.in b/Source/kwsys/Configure.h.in
index 224047a7b..bec1abca4 100644
--- a/Source/kwsys/Configure.h.in
+++ b/Source/kwsys/Configure.h.in
@@ -7,22 +7,22 @@
    namespace.  When not building a kwsys source file these macros are
    temporarily defined inside the headers that use them.  */
 #if defined(KWSYS_NAMESPACE)
-#define kwsys_ns(x) @KWSYS_NAMESPACE@##x
-#define kwsysEXPORT @KWSYS_NAMESPACE@_EXPORT
+#  define kwsys_ns(x) @KWSYS_NAMESPACE@##x
+#  define kwsysEXPORT @KWSYS_NAMESPACE@_EXPORT
 #endif
 
 /* Disable some warnings inside kwsys source files.  */
 #if defined(KWSYS_NAMESPACE)
-#if defined(__BORLANDC__)
-#pragma warn - 8027 /* function not inlined.  */
-#endif
-#if defined(__INTEL_COMPILER)
-#pragma warning(disable : 1572) /* floating-point equality test */
-#endif
-#if defined(__sgi) && !defined(__GNUC__)
-#pragma set woff 3970 /* pointer to int conversion */
-#pragma set woff 3968 /* 64 bit conversion */
-#endif
+#  if defined(__BORLANDC__)
+#    pragma warn - 8027 /* function not inlined.  */
+#  endif
+#  if defined(__INTEL_COMPILER)
+#    pragma warning(disable : 1572) /* floating-point equality test */
+#  endif
+#  if defined(__sgi) && !defined(__GNUC__)
+#    pragma set woff 3970 /* pointer to int conversion */
+#    pragma set woff 3968 /* 64 bit conversion */
+#  endif
 #endif
 
 /* Whether kwsys namespace is "kwsys".  */
@@ -33,81 +33,83 @@
 
 /* Whether Large File Support is available.  */
 #if @KWSYS_NAMESPACE@_LFS_REQUESTED
-#define @KWSYS_NAMESPACE@_LFS_AVAILABLE @KWSYS_LFS_AVAILABLE@
+#  define @KWSYS_NAMESPACE@_LFS_AVAILABLE @KWSYS_LFS_AVAILABLE@
 #endif
 
 /* Setup Large File Support if requested.  */
 #if @KWSYS_NAMESPACE@_LFS_REQUESTED
 /* Since LFS is requested this header must be included before system
    headers whether or not LFS is available. */
-#if 0 && (defined(_SYS_TYPES_H) || defined(_SYS_TYPES_INCLUDED))
-#error "@KWSYS_NAMESPACE@/Configure.h must be included before sys/types.h"
-#endif
+#  if 0 && (defined(_SYS_TYPES_H) || defined(_SYS_TYPES_INCLUDED))
+#    error "@KWSYS_NAMESPACE@/Configure.h must be included before sys/types.h"
+#  endif
 /* Enable the large file API if it is available.  */
-#if @KWSYS_NAMESPACE@_LFS_AVAILABLE &&                                        \
-  !defined(@KWSYS_NAMESPACE@_LFS_NO_DEFINES)
-#if !defined(_LARGEFILE_SOURCE) &&                                            \
-  !defined(@KWSYS_NAMESPACE@_LFS_NO_DEFINE_LARGEFILE_SOURCE)
-#define _LARGEFILE_SOURCE
-#endif
-#if !defined(_LARGEFILE64_SOURCE) &&                                          \
-  !defined(@KWSYS_NAMESPACE@_LFS_NO_DEFINE_LARGEFILE64_SOURCE)
-#define _LARGEFILE64_SOURCE
-#endif
-#if !defined(_LARGE_FILES) &&                                                 \
-  !defined(@KWSYS_NAMESPACE@_LFS_NO_DEFINE_LARGE_FILES)
-#define _LARGE_FILES
-#endif
-#if !defined(_FILE_OFFSET_BITS) &&                                            \
-  !defined(@KWSYS_NAMESPACE@_LFS_NO_DEFINE_FILE_OFFSET_BITS)
-#define _FILE_OFFSET_BITS 64
-#endif
-#endif
+#  if @KWSYS_NAMESPACE@_LFS_AVAILABLE &&                                      \
+    !defined(@KWSYS_NAMESPACE@_LFS_NO_DEFINES)
+#    if !defined(_LARGEFILE_SOURCE) &&                                        \
+      !defined(@KWSYS_NAMESPACE@_LFS_NO_DEFINE_LARGEFILE_SOURCE)
+#      define _LARGEFILE_SOURCE
+#    endif
+#    if !defined(_LARGEFILE64_SOURCE) &&                                      \
+      !defined(@KWSYS_NAMESPACE@_LFS_NO_DEFINE_LARGEFILE64_SOURCE)
+#      define _LARGEFILE64_SOURCE
+#    endif
+#    if !defined(_LARGE_FILES) &&                                             \
+      !defined(@KWSYS_NAMESPACE@_LFS_NO_DEFINE_LARGE_FILES)
+#      define _LARGE_FILES
+#    endif
+#    if !defined(_FILE_OFFSET_BITS) &&                                        \
+      !defined(@KWSYS_NAMESPACE@_LFS_NO_DEFINE_FILE_OFFSET_BITS)
+#      define _FILE_OFFSET_BITS 64
+#    endif
+#  endif
 #endif
 
 /* Setup the export macro.  */
 #if @KWSYS_BUILD_SHARED@
-#if defined(_WIN32) || defined(__CYGWIN__)
-#if defined(@KWSYS_NAMESPACE@_EXPORTS)
-#define @KWSYS_NAMESPACE@_EXPORT __declspec(dllexport)
+#  if defined(_WIN32) || defined(__CYGWIN__)
+#    if defined(@KWSYS_NAMESPACE@_EXPORTS)
+#      define @KWSYS_NAMESPACE@_EXPORT __declspec(dllexport)
+#    else
+#      define @KWSYS_NAMESPACE@_EXPORT __declspec(dllimport)
+#    endif
+#  elif __GNUC__ >= 4
+#    define @KWSYS_NAMESPACE@_EXPORT __attribute__((visibility("default")))
+#  else
+#    define @KWSYS_NAMESPACE@_EXPORT
+#  endif
 #else
-#define @KWSYS_NAMESPACE@_EXPORT __declspec(dllimport)
-#endif
-#elif __GNUC__ >= 4
-#define @KWSYS_NAMESPACE@_EXPORT __attribute__((visibility("default")))
-#else
-#define @KWSYS_NAMESPACE@_EXPORT
-#endif
-#else
-#define @KWSYS_NAMESPACE@_EXPORT
+#  define @KWSYS_NAMESPACE@_EXPORT
 #endif
 
 /* Enable warnings that are off by default but are useful.  */
 #if !defined(@KWSYS_NAMESPACE@_NO_WARNING_ENABLE)
-#if defined(_MSC_VER)
-#pragma warning(default : 4263) /* no override, call convention differs */
-#endif
+#  if defined(_MSC_VER)
+#    pragma warning(default : 4263) /* no override, call convention differs   \
+                                     */
+#  endif
 #endif
 
 /* Disable warnings that are on by default but occur in valid code.  */
 #if !defined(@KWSYS_NAMESPACE@_NO_WARNING_DISABLE)
-#if defined(_MSC_VER)
-#pragma warning(disable : 4097) /* typedef is synonym for class */
-#pragma warning(disable : 4127) /* conditional expression is constant */
-#pragma warning(disable : 4244) /* possible loss in conversion */
-#pragma warning(disable : 4251) /* missing DLL-interface */
-#pragma warning(disable : 4305) /* truncation from type1 to type2 */
-#pragma warning(disable : 4309) /* truncation of constant value */
-#pragma warning(disable : 4514) /* unreferenced inline function */
-#pragma warning(disable : 4706) /* assignment in conditional expression */
-#pragma warning(disable : 4710) /* function not inlined */
-#pragma warning(disable : 4786) /* identifier truncated in debug info */
-#endif
-#if defined(__BORLANDC__) && !defined(__cplusplus)
+#  if defined(_MSC_VER)
+#    pragma warning(disable : 4097) /* typedef is synonym for class */
+#    pragma warning(disable : 4127) /* conditional expression is constant */
+#    pragma warning(disable : 4244) /* possible loss in conversion */
+#    pragma warning(disable : 4251) /* missing DLL-interface */
+#    pragma warning(disable : 4305) /* truncation from type1 to type2 */
+#    pragma warning(disable : 4309) /* truncation of constant value */
+#    pragma warning(disable : 4514) /* unreferenced inline function */
+#    pragma warning(disable : 4706) /* assignment in conditional expression   \
+                                     */
+#    pragma warning(disable : 4710) /* function not inlined */
+#    pragma warning(disable : 4786) /* identifier truncated in debug info */
+#  endif
+#  if defined(__BORLANDC__) && !defined(__cplusplus)
 /* Code has no effect; raised by winnt.h in C (not C++) when ignoring an
    unused parameter using "(param)" syntax (i.e. no cast to void).  */
-#pragma warn - 8019
-#endif
+#    pragma warn - 8019
+#  endif
 #endif
 
 /* MSVC 6.0 in release mode will warn about code it produces with its
@@ -115,10 +117,10 @@
    configuration.  Real warnings will be revealed by a debug build or
    by other compilers.  */
 #if !defined(@KWSYS_NAMESPACE@_NO_WARNING_DISABLE_BOGUS)
-#if defined(_MSC_VER) && (_MSC_VER < 1300) && defined(NDEBUG)
-#pragma warning(disable : 4701) /* Variable may be used uninitialized.  */
-#pragma warning(disable : 4702) /* Unreachable code.  */
-#endif
+#  if defined(_MSC_VER) && (_MSC_VER < 1300) && defined(NDEBUG)
+#    pragma warning(disable : 4701) /* Variable may be used uninitialized. */
+#    pragma warning(disable : 4702) /* Unreachable code.  */
+#  endif
 #endif
 
 #endif
diff --git a/Source/kwsys/Configure.hxx.in b/Source/kwsys/Configure.hxx.in
index 05afc7d12..d1e7464ff 100644
--- a/Source/kwsys/Configure.hxx.in
+++ b/Source/kwsys/Configure.hxx.in
@@ -13,32 +13,33 @@
   @KWSYS_CXX_HAS_EXT_STDIO_FILEBUF_H@
 
 #if defined(__SUNPRO_CC) && __SUNPRO_CC > 0x5130 && defined(__has_attribute)
-#define @KWSYS_NAMESPACE@__has_cpp_attribute(x) __has_attribute(x)
+#  define @KWSYS_NAMESPACE@__has_cpp_attribute(x) __has_attribute(x)
 #elif defined(__has_cpp_attribute)
-#define @KWSYS_NAMESPACE@__has_cpp_attribute(x) __has_cpp_attribute(x)
+#  define @KWSYS_NAMESPACE@__has_cpp_attribute(x) __has_cpp_attribute(x)
 #else
-#define @KWSYS_NAMESPACE@__has_cpp_attribute(x) 0
+#  define @KWSYS_NAMESPACE@__has_cpp_attribute(x) 0
 #endif
 
 #if __cplusplus >= 201103L
-#define @KWSYS_NAMESPACE@_NULLPTR nullptr
+#  define @KWSYS_NAMESPACE@_NULLPTR nullptr
 #else
-#define @KWSYS_NAMESPACE@_NULLPTR 0
+#  define @KWSYS_NAMESPACE@_NULLPTR 0
 #endif
 
 #ifndef @KWSYS_NAMESPACE@_FALLTHROUGH
-#if __cplusplus >= 201703L && @KWSYS_NAMESPACE@__has_cpp_attribute(fallthrough)
-#define @KWSYS_NAMESPACE@_FALLTHROUGH [[fallthrough]]
-#elif __cplusplus >= 201103L &&                                               \
-  @KWSYS_NAMESPACE@__has_cpp_attribute(gnu::fallthrough)
-#define @KWSYS_NAMESPACE@_FALLTHROUGH [[gnu::fallthrough]]
-#elif __cplusplus >= 201103L &&                                               \
-  @KWSYS_NAMESPACE@__has_cpp_attribute(clang::fallthrough)
-#define @KWSYS_NAMESPACE@_FALLTHROUGH [[clang::fallthrough]]
-#endif
+#  if __cplusplus >= 201703L &&                                               \
+    @KWSYS_NAMESPACE@__has_cpp_attribute(fallthrough)
+#    define @KWSYS_NAMESPACE@_FALLTHROUGH [[fallthrough]]
+#  elif __cplusplus >= 201103L &&                                             \
+    @KWSYS_NAMESPACE@__has_cpp_attribute(gnu::fallthrough)
+#    define @KWSYS_NAMESPACE@_FALLTHROUGH [[gnu::fallthrough]]
+#  elif __cplusplus >= 201103L &&                                             \
+    @KWSYS_NAMESPACE@__has_cpp_attribute(clang::fallthrough)
+#    define @KWSYS_NAMESPACE@_FALLTHROUGH [[clang::fallthrough]]
+#  endif
 #endif
 #ifndef @KWSYS_NAMESPACE@_FALLTHROUGH
-#define @KWSYS_NAMESPACE@_FALLTHROUGH static_cast<void>(0)
+#  define @KWSYS_NAMESPACE@_FALLTHROUGH static_cast<void>(0)
 #endif
 
 #undef @KWSYS_NAMESPACE@__has_cpp_attribute
@@ -46,15 +47,15 @@
 /* If building a C++ file in kwsys itself, give the source file
    access to the macros without a configured namespace.  */
 #if defined(KWSYS_NAMESPACE)
-#if !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
-#define kwsys @KWSYS_NAMESPACE@
-#endif
-#define KWSYS_NAME_IS_KWSYS @KWSYS_NAMESPACE@_NAME_IS_KWSYS
-#define KWSYS_STL_HAS_WSTRING @KWSYS_NAMESPACE@_STL_HAS_WSTRING
-#define KWSYS_CXX_HAS_EXT_STDIO_FILEBUF_H                                     \
-  @KWSYS_NAMESPACE@_CXX_HAS_EXT_STDIO_FILEBUF_H
-#define KWSYS_FALLTHROUGH @KWSYS_NAMESPACE@_FALLTHROUGH
-#define KWSYS_NULLPTR @KWSYS_NAMESPACE@_NULLPTR
+#  if !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
+#    define kwsys @KWSYS_NAMESPACE@
+#  endif
+#  define KWSYS_NAME_IS_KWSYS @KWSYS_NAMESPACE@_NAME_IS_KWSYS
+#  define KWSYS_STL_HAS_WSTRING @KWSYS_NAMESPACE@_STL_HAS_WSTRING
+#  define KWSYS_CXX_HAS_EXT_STDIO_FILEBUF_H                                   \
+    @KWSYS_NAMESPACE@_CXX_HAS_EXT_STDIO_FILEBUF_H
+#  define KWSYS_FALLTHROUGH @KWSYS_NAMESPACE@_FALLTHROUGH
+#  define KWSYS_NULLPTR @KWSYS_NAMESPACE@_NULLPTR
 #endif
 
 #endif
diff --git a/Source/kwsys/ConsoleBuf.hxx.in b/Source/kwsys/ConsoleBuf.hxx.in
index cf68146c4..73a1efb25 100644
--- a/Source/kwsys/ConsoleBuf.hxx.in
+++ b/Source/kwsys/ConsoleBuf.hxx.in
@@ -15,10 +15,10 @@
 #include <string>
 
 #if defined(_WIN32)
-#include <windows.h>
-#if __cplusplus >= 201103L
-#include <system_error>
-#endif
+#  include <windows.h>
+#  if __cplusplus >= 201103L
+#    include <system_error>
+#  endif
 #endif
 
 namespace @KWSYS_NAMESPACE@ {
@@ -231,12 +231,12 @@ private:
         (!input && m_hOutput == INVALID_HANDLE_VALUE)) {
       std::string errmsg =
         "GetStdHandle(" + handleName + ") returned INVALID_HANDLE_VALUE";
-#if __cplusplus >= 201103L
+#  if __cplusplus >= 201103L
       throw std::system_error(::GetLastError(), std::system_category(),
                               errmsg);
-#else
+#  else
       throw std::runtime_error(errmsg);
-#endif
+#  endif
     }
   }
   UINT getConsolesCodepage()
diff --git a/Source/kwsys/Directory.cxx b/Source/kwsys/Directory.cxx
index a84be1186..31b1c15d0 100644
--- a/Source/kwsys/Directory.cxx
+++ b/Source/kwsys/Directory.cxx
@@ -10,9 +10,9 @@
 // Work-around CMake dependency scanning limitation.  This must
 // duplicate the above list of headers.
 #if 0
-#include "Configure.hxx.in"
-#include "Directory.hxx.in"
-#include "Encoding.hxx.in"
+#  include "Configure.hxx.in"
+#  include "Directory.hxx.in"
+#  include "Encoding.hxx.in"
 #endif
 
 #include <string>
@@ -69,37 +69,37 @@ void Directory::Clear()
 // First Windows platforms
 
 #if defined(_WIN32) && !defined(__CYGWIN__)
-#include <windows.h>
+#  include <windows.h>
 
-#include <ctype.h>
-#include <fcntl.h>
-#include <io.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/stat.h>
-#include <sys/types.h>
+#  include <ctype.h>
+#  include <fcntl.h>
+#  include <io.h>
+#  include <stdio.h>
+#  include <stdlib.h>
+#  include <string.h>
+#  include <sys/stat.h>
+#  include <sys/types.h>
 
 // Wide function names can vary depending on compiler:
-#ifdef __BORLANDC__
-#define _wfindfirst_func __wfindfirst
-#define _wfindnext_func __wfindnext
-#else
-#define _wfindfirst_func _wfindfirst
-#define _wfindnext_func _wfindnext
-#endif
+#  ifdef __BORLANDC__
+#    define _wfindfirst_func __wfindfirst
+#    define _wfindnext_func __wfindnext
+#  else
+#    define _wfindfirst_func _wfindfirst
+#    define _wfindnext_func _wfindnext
+#  endif
 
 namespace KWSYS_NAMESPACE {
 
 bool Directory::Load(const std::string& name)
 {
   this->Clear();
-#if (defined(_MSC_VER) && _MSC_VER < 1300) || defined(__BORLANDC__)
+#  if (defined(_MSC_VER) && _MSC_VER < 1300) || defined(__BORLANDC__)
   // Older Visual C++ and Embarcadero compilers.
   long srchHandle;
-#else // Newer Visual C++
+#  else // Newer Visual C++
   intptr_t srchHandle;
-#endif
+#  endif
   char* buf;
   size_t n = name.size();
   if (*name.rbegin() == '/' || *name.rbegin() == '\\') {
@@ -136,12 +136,12 @@ bool Directory::Load(const std::string& name)
 
 unsigned long Directory::GetNumberOfFilesInDirectory(const std::string& name)
 {
-#if (defined(_MSC_VER) && _MSC_VER < 1300) || defined(__BORLANDC__)
+#  if (defined(_MSC_VER) && _MSC_VER < 1300) || defined(__BORLANDC__)
   // Older Visual C++ and Embarcadero compilers.
   long srchHandle;
-#else // Newer Visual C++
+#  else // Newer Visual C++
   intptr_t srchHandle;
-#endif
+#  endif
   char* buf;
   size_t n = name.size();
   if (*name.rbegin() == '/') {
@@ -177,23 +177,23 @@ unsigned long Directory::GetNumberOfFilesInDirectory(const std::string& name)
 
 // Now the POSIX style directory access
 
-#include <sys/types.h>
+#  include <sys/types.h>
 
-#include <dirent.h>
+#  include <dirent.h>
 
 // PGI with glibc has trouble with dirent and large file support:
 //  http://www.pgroup.com/userforum/viewtopic.php?
 //  p=1992&sid=f16167f51964f1a68fe5041b8eb213b6
 // Work around the problem by mapping dirent the same way as readdir.
-#if defined(__PGI) && defined(__GLIBC__)
-#define kwsys_dirent_readdir dirent
-#define kwsys_dirent_readdir64 dirent64
-#define kwsys_dirent kwsys_dirent_lookup(readdir)
-#define kwsys_dirent_lookup(x) kwsys_dirent_lookup_delay(x)
-#define kwsys_dirent_lookup_delay(x) kwsys_dirent_##x
-#else
-#define kwsys_dirent dirent
-#endif
+#  if defined(__PGI) && defined(__GLIBC__)
+#    define kwsys_dirent_readdir dirent
+#    define kwsys_dirent_readdir64 dirent64
+#    define kwsys_dirent kwsys_dirent_lookup(readdir)
+#    define kwsys_dirent_lookup(x) kwsys_dirent_lookup_delay(x)
+#    define kwsys_dirent_lookup_delay(x) kwsys_dirent_##x
+#  else
+#    define kwsys_dirent dirent
+#  endif
 
 namespace KWSYS_NAMESPACE {
 
diff --git a/Source/kwsys/DynamicLoader.cxx b/Source/kwsys/DynamicLoader.cxx
index 9b7d9bfc7..a85690f7c 100644
--- a/Source/kwsys/DynamicLoader.cxx
+++ b/Source/kwsys/DynamicLoader.cxx
@@ -8,8 +8,8 @@
 // Work-around CMake dependency scanning limitation.  This must
 // duplicate the above list of headers.
 #if 0
-#include "Configure.hxx.in"
-#include "DynamicLoader.hxx.in"
+#  include "Configure.hxx.in"
+#  include "DynamicLoader.hxx.in"
 #endif
 
 // This file actually contains several different implementations:
@@ -27,7 +27,7 @@
 
 #if !KWSYS_SUPPORTS_SHARED_LIBS
 // Implementation for environments without dynamic libs
-#include <string.h> // for strerror()
+#  include <string.h> // for strerror()
 
 namespace KWSYS_NAMESPACE {
 
@@ -61,8 +61,8 @@ const char* DynamicLoader::LastError()
 
 #elif defined(__hpux)
 // Implementation for HPUX machines
-#include <dl.h>
-#include <errno.h>
+#  include <dl.h>
+#  include <errno.h>
 
 namespace KWSYS_NAMESPACE {
 
@@ -124,8 +124,8 @@ const char* DynamicLoader::LastError()
 
 #elif defined(__APPLE__) && (MAC_OS_X_VERSION_MAX_ALLOWED < 1030)
 // Implementation for Mac OS X 10.2.x and earlier
-#include <mach-o/dyld.h>
-#include <string.h> // for strlen
+#  include <mach-o/dyld.h>
+#  include <string.h> // for strlen
 
 namespace KWSYS_NAMESPACE {
 
@@ -140,9 +140,9 @@ DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(
   if (rc != NSObjectFileImageSuccess) {
     return 0;
   }
-  NSModule handle =
-    NSLinkModule(image, libname.c_str(), NSLINKMODULE_OPTION_BINDNOW |
-                   NSLINKMODULE_OPTION_RETURN_ON_ERROR);
+  NSModule handle = NSLinkModule(image, libname.c_str(),
+                                 NSLINKMODULE_OPTION_BINDNOW |
+                                   NSLINKMODULE_OPTION_RETURN_ON_ERROR);
   NSDestroyObjectFileImage(image);
   return handle;
 }
@@ -183,7 +183,7 @@ const char* DynamicLoader::LastError()
 
 #elif defined(_WIN32) && !defined(__CYGWIN__)
 // Implementation for Windows win32 code but not cygwin
-#include <windows.h>
+#  include <windows.h>
 
 namespace KWSYS_NAMESPACE {
 
@@ -231,20 +231,20 @@ DynamicLoader::SymbolPointer DynamicLoader::GetSymbolAddress(
   // Note that the "@X" part of the name above is the total size (in
   // bytes) of the arguments on the stack.
   void* result;
-#if defined(__BORLANDC__) || defined(__WATCOMC__)
+#  if defined(__BORLANDC__) || defined(__WATCOMC__)
   // Need to prepend symbols with '_'
   std::string ssym = '_' + sym;
   const char* rsym = ssym.c_str();
-#else
+#  else
   const char* rsym = sym.c_str();
-#endif
+#  endif
   result = (void*)GetProcAddress(lib, rsym);
 // Hack to cast pointer-to-data to pointer-to-function.
-#ifdef __WATCOMC__
+#  ifdef __WATCOMC__
   return *(DynamicLoader::SymbolPointer*)(&result);
-#else
+#  else
   return *reinterpret_cast<DynamicLoader::SymbolPointer*>(&result);
-#endif
+#  endif
 }
 
 const char* DynamicLoader::LastError()
@@ -272,10 +272,10 @@ const char* DynamicLoader::LastError()
 
 #elif defined(__BEOS__)
 // Implementation for BeOS / Haiku
-#include <string.h> // for strerror()
+#  include <string.h> // for strerror()
 
-#include <be/kernel/image.h>
-#include <be/support/Errors.h>
+#  include <be/kernel/image.h>
+#  include <be/support/Errors.h>
 
 namespace KWSYS_NAMESPACE {
 
@@ -351,11 +351,11 @@ const char* DynamicLoader::LastError()
 
 #elif defined(__MINT__)
 // Implementation for FreeMiNT on Atari
-#define _GNU_SOURCE /* for program_invocation_name */
-#include <dld.h>
-#include <errno.h>
-#include <malloc.h>
-#include <string.h>
+#  define _GNU_SOURCE /* for program_invocation_name */
+#  include <dld.h>
+#  include <errno.h>
+#  include <malloc.h>
+#  include <string.h>
 
 namespace KWSYS_NAMESPACE {
 
@@ -399,7 +399,7 @@ const char* DynamicLoader::LastError()
 #else
 // Default implementation for *NIX systems (including Mac OS X 10.3 and
 // later) which use dlopen
-#include <dlfcn.h>
+#  include <dlfcn.h>
 
 namespace KWSYS_NAMESPACE {
 
diff --git a/Source/kwsys/DynamicLoader.hxx.in b/Source/kwsys/DynamicLoader.hxx.in
index dc3469266..08f2790af 100644
--- a/Source/kwsys/DynamicLoader.hxx.in
+++ b/Source/kwsys/DynamicLoader.hxx.in
@@ -8,16 +8,16 @@
 #include <string>
 
 #if defined(__hpux)
-#include <dl.h>
+#  include <dl.h>
 #elif defined(_WIN32) && !defined(__CYGWIN__)
-#include <windows.h>
+#  include <windows.h>
 #elif defined(__APPLE__)
-#include <AvailabilityMacros.h>
-#if MAC_OS_X_VERSION_MAX_ALLOWED < 1030
-#include <mach-o/dyld.h>
-#endif
+#  include <AvailabilityMacros.h>
+#  if MAC_OS_X_VERSION_MAX_ALLOWED < 1030
+#    include <mach-o/dyld.h>
+#  endif
 #elif defined(__BEOS__)
-#include <be/kernel/image.h>
+#  include <be/kernel/image.h>
 #endif
 
 namespace @KWSYS_NAMESPACE@ {
@@ -52,11 +52,11 @@ public:
 #elif defined(_WIN32) && !defined(__CYGWIN__)
   typedef HMODULE LibraryHandle;
 #elif defined(__APPLE__)
-#if MAC_OS_X_VERSION_MAX_ALLOWED < 1030
+#  if MAC_OS_X_VERSION_MAX_ALLOWED < 1030
   typedef NSModule LibraryHandle;
-#else
+#  else
   typedef void* LibraryHandle;
-#endif
+#  endif
 #elif defined(__BEOS__)
   typedef image_id LibraryHandle;
 #else // POSIX
diff --git a/Source/kwsys/Encoding.h.in b/Source/kwsys/Encoding.h.in
index 7b6ed10f8..86a26692a 100644
--- a/Source/kwsys/Encoding.h.in
+++ b/Source/kwsys/Encoding.h.in
@@ -12,15 +12,15 @@
    not visible to user code.  Use kwsysHeaderDump.pl to reproduce
    these macros after making changes to the interface.  */
 #if !defined(KWSYS_NAMESPACE)
-#define kwsys_ns(x) @KWSYS_NAMESPACE@##x
-#define kwsysEXPORT @KWSYS_NAMESPACE@_EXPORT
+#  define kwsys_ns(x) @KWSYS_NAMESPACE@##x
+#  define kwsysEXPORT @KWSYS_NAMESPACE@_EXPORT
 #endif
 #if !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
-#define kwsysEncoding kwsys_ns(Encoding)
-#define kwsysEncoding_mbstowcs kwsys_ns(Encoding_mbstowcs)
-#define kwsysEncoding_DupToWide kwsys_ns(Encoding_DupToWide)
-#define kwsysEncoding_wcstombs kwsys_ns(Encoding_wcstombs)
-#define kwsysEncoding_DupToNarrow kwsys_ns(Encoding_DupToNarrow)
+#  define kwsysEncoding kwsys_ns(Encoding)
+#  define kwsysEncoding_mbstowcs kwsys_ns(Encoding_mbstowcs)
+#  define kwsysEncoding_DupToWide kwsys_ns(Encoding_DupToWide)
+#  define kwsysEncoding_wcstombs kwsys_ns(Encoding_wcstombs)
+#  define kwsysEncoding_DupToNarrow kwsys_ns(Encoding_DupToNarrow)
 #endif
 
 #if defined(__cplusplus)
@@ -55,15 +55,15 @@ kwsysEXPORT char* kwsysEncoding_DupToNarrow(const wchar_t* str);
 /* If we are building a kwsys .c or .cxx file, let it use these macros.
    Otherwise, undefine them to keep the namespace clean.  */
 #if !defined(KWSYS_NAMESPACE)
-#undef kwsys_ns
-#undef kwsysEXPORT
-#if !defined(KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
-#undef kwsysEncoding
-#undef kwsysEncoding_mbstowcs
-#undef kwsysEncoding_DupToWide
-#undef kwsysEncoding_wcstombs
-#undef kwsysEncoding_DupToNarrow
-#endif
+#  undef kwsys_ns
+#  undef kwsysEXPORT
+#  if !defined(KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
+#    undef kwsysEncoding
+#    undef kwsysEncoding_mbstowcs
+#    undef kwsysEncoding_DupToWide
+#    undef kwsysEncoding_wcstombs
+#    undef kwsysEncoding_DupToNarrow
+#  endif
 #endif
 
 #endif
diff --git a/Source/kwsys/Encoding.hxx.in b/Source/kwsys/Encoding.hxx.in
index 09691fd3f..b06752115 100644
--- a/Source/kwsys/Encoding.hxx.in
+++ b/Source/kwsys/Encoding.hxx.in
@@ -41,9 +41,9 @@ public:
     std::vector<char*> argv_;
   };
 
-/**
- * Convert between char and wchar_t
- */
+  /**
+   * Convert between char and wchar_t
+   */
 
 #if @KWSYS_NAMESPACE@_STL_HAS_WSTRING
 
@@ -59,7 +59,7 @@ public:
   static std::string ToNarrow(const std::wstring& str);
   static std::string ToNarrow(const wchar_t* str);
 
-#if defined(_WIN32)
+#  if defined(_WIN32)
   /**
    * Convert the path to an extended length path to avoid MAX_PATH length
    * limitations on Windows. If the input is a local path the result will be
@@ -68,7 +68,7 @@ public:
    * absolute paths with Windows-style backslashes.
    **/
   static std::wstring ToWindowsExtendedPath(std::string const&);
-#endif
+#  endif
 
 #endif // @KWSYS_NAMESPACE@_STL_HAS_WSTRING
 
diff --git a/Source/kwsys/EncodingC.c b/Source/kwsys/EncodingC.c
index c1315b2d5..e12236afe 100644
--- a/Source/kwsys/EncodingC.c
+++ b/Source/kwsys/EncodingC.c
@@ -6,13 +6,13 @@
 /* Work-around CMake dependency scanning limitation.  This must
    duplicate the above list of headers.  */
 #if 0
-#include "Encoding.h.in"
+#  include "Encoding.h.in"
 #endif
 
 #include <stdlib.h>
 
 #ifdef _WIN32
-#include <windows.h>
+#  include <windows.h>
 #endif
 
 size_t kwsysEncoding_mbstowcs(wchar_t* dest, const char* str, size_t n)
diff --git a/Source/kwsys/EncodingCXX.cxx b/Source/kwsys/EncodingCXX.cxx
index a1fe040d2..251deef3d 100644
--- a/Source/kwsys/EncodingCXX.cxx
+++ b/Source/kwsys/EncodingCXX.cxx
@@ -1,9 +1,9 @@
 /* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
    file Copyright.txt or https://cmake.org/licensing#kwsys for details.  */
 #ifdef __osf__
-#define _OSF_SOURCE
-#define _POSIX_C_SOURCE 199506L
-#define _XOPEN_SOURCE_EXTENDED
+#  define _OSF_SOURCE
+#  define _POSIX_C_SOURCE 199506L
+#  define _XOPEN_SOURCE_EXTENDED
 #endif
 
 #include "kwsysPrivate.h"
@@ -13,8 +13,8 @@
 // Work-around CMake dependency scanning limitation.  This must
 // duplicate the above list of headers.
 #if 0
-#include "Encoding.h.in"
-#include "Encoding.hxx.in"
+#  include "Encoding.h.in"
+#  include "Encoding.hxx.in"
 #endif
 
 #include <stdlib.h>
@@ -22,15 +22,15 @@
 #include <vector>
 
 #ifdef _MSC_VER
-#pragma warning(disable : 4786)
+#  pragma warning(disable : 4786)
 #endif
 
 // Windows API.
 #if defined(_WIN32)
-#include <windows.h>
+#  include <windows.h>
 
-#include <ctype.h>
-#include <shellapi.h>
+#  include <ctype.h>
+#  include <shellapi.h>
 #endif
 
 namespace KWSYS_NAMESPACE {
@@ -127,7 +127,7 @@ char const* const* Encoding::CommandLineArguments::argv() const
 std::wstring Encoding::ToWide(const std::string& str)
 {
   std::wstring wstr;
-#if defined(_WIN32)
+#  if defined(_WIN32)
   const int wlength = MultiByteToWideChar(
     KWSYS_ENCODING_DEFAULT_CODEPAGE, 0, str.data(), int(str.size()), NULL, 0);
   if (wlength > 0) {
@@ -139,7 +139,7 @@ std::wstring Encoding::ToWide(const std::string& str)
     }
     delete[] wdata;
   }
-#else
+#  else
   size_t pos = 0;
   size_t nullPos = 0;
   do {
@@ -152,14 +152,14 @@ std::wstring Encoding::ToWide(const std::string& str)
       wstr += wchar_t('\0');
     }
   } while (nullPos != std::string::npos);
-#endif
+#  endif
   return wstr;
 }
 
 std::string Encoding::ToNarrow(const std::wstring& str)
 {
   std::string nstr;
-#if defined(_WIN32)
+#  if defined(_WIN32)
   int length =
     WideCharToMultiByte(KWSYS_ENCODING_DEFAULT_CODEPAGE, 0, str.c_str(),
                         int(str.size()), NULL, 0, NULL, NULL);
@@ -173,7 +173,7 @@ std::string Encoding::ToNarrow(const std::wstring& str)
     }
     delete[] data;
   }
-#else
+#  else
   size_t pos = 0;
   size_t nullPos = 0;
   do {
@@ -186,7 +186,7 @@ std::string Encoding::ToNarrow(const std::wstring& str)
       nstr += '\0';
     }
   } while (nullPos != std::string::npos);
-#endif
+#  endif
   return nstr;
 }
 
@@ -216,7 +216,7 @@ std::string Encoding::ToNarrow(const wchar_t* wcstr)
   return str;
 }
 
-#if defined(_WIN32)
+#  if defined(_WIN32)
 // Convert local paths to UNC style paths
 std::wstring Encoding::ToWindowsExtendedPath(std::string const& source)
 {
@@ -270,7 +270,7 @@ std::wstring Encoding::ToWindowsExtendedPath(std::string const& source)
   // unchanged
   return Encoding::ToWide(source);
 }
-#endif
+#  endif
 
 #endif // KWSYS_STL_HAS_WSTRING
 
diff --git a/Source/kwsys/FStream.cxx b/Source/kwsys/FStream.cxx
index 3c44a6fa0..5e4133ac5 100644
--- a/Source/kwsys/FStream.cxx
+++ b/Source/kwsys/FStream.cxx
@@ -6,7 +6,7 @@
 // Work-around CMake dependency scanning limitation.  This must
 // duplicate the above list of headers.
 #if 0
-#include "FStream.hxx.in"
+#  include "FStream.hxx.in"
 #endif
 
 namespace KWSYS_NAMESPACE {
diff --git a/Source/kwsys/FStream.hxx.in b/Source/kwsys/FStream.hxx.in
index a4c65fe30..d79bbdf16 100644
--- a/Source/kwsys/FStream.hxx.in
+++ b/Source/kwsys/FStream.hxx.in
@@ -9,26 +9,26 @@
 
 #include <fstream>
 #if defined(_WIN32)
-#if !defined(_MSC_VER) && @KWSYS_NAMESPACE@_CXX_HAS_EXT_STDIO_FILEBUF_H
-#include <ext/stdio_filebuf.h>
-#endif
+#  if !defined(_MSC_VER) && @KWSYS_NAMESPACE@_CXX_HAS_EXT_STDIO_FILEBUF_H
+#    include <ext/stdio_filebuf.h>
+#  endif
 #endif
 
 namespace @KWSYS_NAMESPACE@ {
 #if defined(_WIN32) &&                                                        \
   (defined(_MSC_VER) || @KWSYS_NAMESPACE@_CXX_HAS_EXT_STDIO_FILEBUF_H)
-#if defined(_NOEXCEPT)
-#define @KWSYS_NAMESPACE@_FStream_NOEXCEPT _NOEXCEPT
-#else
-#define @KWSYS_NAMESPACE@_FStream_NOEXCEPT
-#endif
+#  if defined(_NOEXCEPT)
+#    define @KWSYS_NAMESPACE@_FStream_NOEXCEPT _NOEXCEPT
+#  else
+#    define @KWSYS_NAMESPACE@_FStream_NOEXCEPT
+#  endif
 
-#if defined(_MSC_VER)
+#  if defined(_MSC_VER)
 
 template <typename CharType, typename Traits>
 class basic_filebuf : public std::basic_filebuf<CharType, Traits>
 {
-#if _MSC_VER >= 1400
+#    if _MSC_VER >= 1400
 public:
   typedef std::basic_filebuf<CharType, Traits> my_base_type;
   basic_filebuf* open(char const* s, std::ios_base::openmode mode)
@@ -36,10 +36,10 @@ public:
     const std::wstring wstr = Encoding::ToWindowsExtendedPath(s);
     return static_cast<basic_filebuf*>(my_base_type::open(wstr.c_str(), mode));
   }
-#endif
+#    endif
 };
 
-#else
+#  else
 
 inline std::wstring getcmode(const std::ios_base::openmode mode)
 {
@@ -67,17 +67,17 @@ inline std::wstring getcmode(const std::ios_base::openmode mode)
   return cmode;
 };
 
-#endif
+#  endif
 
 template <typename CharType, typename Traits = std::char_traits<CharType> >
 class basic_efilebuf
 {
 public:
-#if defined(_MSC_VER)
+#  if defined(_MSC_VER)
   typedef basic_filebuf<CharType, Traits> internal_buffer_type;
-#else
+#  else
   typedef __gnu_cxx::stdio_filebuf<CharType, Traits> internal_buffer_type;
-#endif
+#  endif
 
   basic_efilebuf()
     : file_(0)
@@ -90,9 +90,9 @@ public:
     if (is_open() || file_) {
       return false;
     }
-#if defined(_MSC_VER)
+#  if defined(_MSC_VER)
     const bool success = buf_->open(file_name, mode) != 0;
-#else
+#  else
     const std::wstring wstr = Encoding::ToWindowsExtendedPath(file_name);
     bool success = false;
     std::wstring cmode = getcmode(mode);
@@ -104,7 +104,7 @@ public:
       buf_ = new internal_buffer_type(file_, mode);
       success = true;
     }
-#endif
+#  endif
     return success;
   }
 
@@ -129,12 +129,12 @@ public:
     bool success = false;
     if (buf_) {
       success = buf_->close() != 0;
-#if !defined(_MSC_VER)
+#  if !defined(_MSC_VER)
       if (file_) {
         success = fclose(file_) == 0 ? success : false;
         file_ = 0;
       }
-#endif
+#  endif
     }
     return success;
   }
@@ -142,11 +142,11 @@ public:
   static void _set_state(bool success, std::basic_ios<CharType, Traits>* ios,
                          basic_efilebuf* efilebuf)
   {
-#if !defined(_MSC_VER)
+#  if !defined(_MSC_VER)
     ios->rdbuf(efilebuf->buf_);
-#else
+#  else
     static_cast<void>(efilebuf);
-#endif
+#  endif
     if (!success) {
       ios->setstate(std::ios_base::failbit);
     } else {
@@ -167,8 +167,9 @@ protected:
 };
 
 template <typename CharType, typename Traits = std::char_traits<CharType> >
-class basic_ifstream : public std::basic_istream<CharType, Traits>,
-                       public basic_efilebuf<CharType, Traits>
+class basic_ifstream
+  : public std::basic_istream<CharType, Traits>
+  , public basic_efilebuf<CharType, Traits>
 {
 public:
   typedef typename basic_efilebuf<CharType, Traits>::internal_buffer_type
@@ -207,8 +208,9 @@ public:
 };
 
 template <typename CharType, typename Traits = std::char_traits<CharType> >
-class basic_ofstream : public std::basic_ostream<CharType, Traits>,
-                       public basic_efilebuf<CharType, Traits>
+class basic_ofstream
+  : public std::basic_ostream<CharType, Traits>
+  , public basic_efilebuf<CharType, Traits>
 {
   using basic_efilebuf<CharType, Traits>::is_open;
 
@@ -248,7 +250,7 @@ public:
 typedef basic_ifstream<char> ifstream;
 typedef basic_ofstream<char> ofstream;
 
-#undef @KWSYS_NAMESPACE@_FStream_NOEXCEPT
+#  undef @KWSYS_NAMESPACE@_FStream_NOEXCEPT
 #else
 using std::ofstream;
 using std::ifstream;
diff --git a/Source/kwsys/Glob.cxx b/Source/kwsys/Glob.cxx
index 2b6db78cf..6952d24ae 100644
--- a/Source/kwsys/Glob.cxx
+++ b/Source/kwsys/Glob.cxx
@@ -12,11 +12,11 @@
 // Work-around CMake dependency scanning limitation.  This must
 // duplicate the above list of headers.
 #if 0
-#include "Configure.hxx.in"
-#include "Directory.hxx.in"
-#include "Glob.hxx.in"
-#include "RegularExpression.hxx.in"
-#include "SystemTools.hxx.in"
+#  include "Configure.hxx.in"
+#  include "Directory.hxx.in"
+#  include "Glob.hxx.in"
+#  include "RegularExpression.hxx.in"
+#  include "SystemTools.hxx.in"
 #endif
 
 #include <algorithm>
@@ -29,12 +29,12 @@
 namespace KWSYS_NAMESPACE {
 #if defined(_WIN32) || defined(__APPLE__) || defined(__CYGWIN__)
 // On Windows and Apple, no difference between lower and upper case
-#define KWSYS_GLOB_CASE_INDEPENDENT
+#  define KWSYS_GLOB_CASE_INDEPENDENT
 #endif
 
 #if defined(_WIN32) || defined(__CYGWIN__)
 // Handle network paths
-#define KWSYS_GLOB_SUPPORT_NETWORK_PATHS
+#  define KWSYS_GLOB_SUPPORT_NETWORK_PATHS
 #endif
 
 class GlobInternals
@@ -217,9 +217,10 @@ bool Glob::RecurseDirectory(std::string::size_type start,
 
         if (!realPathErrorMessage.empty()) {
           if (messages) {
-            messages->push_back(Message(
-              Glob::error, "Canonical path generation from path '" + dir +
-                "' failed! Reason: '" + realPathErrorMessage + "'"));
+            messages->push_back(
+              Message(Glob::error,
+                      "Canonical path generation from path '" + dir +
+                        "' failed! Reason: '" + realPathErrorMessage + "'"));
           }
           return false;
         }
diff --git a/Source/kwsys/IOStream.cxx b/Source/kwsys/IOStream.cxx
index 01ada1f2f..e21f87d45 100644
--- a/Source/kwsys/IOStream.cxx
+++ b/Source/kwsys/IOStream.cxx
@@ -10,21 +10,21 @@
 // Work-around CMake dependency scanning limitation.  This must
 // duplicate the above list of headers.
 #if 0
-#include "Configure.hxx.in"
-#include "IOStream.hxx.in"
+#  include "Configure.hxx.in"
+#  include "IOStream.hxx.in"
 #endif
 
 // Implement the rest of this file only if it is needed.
 #if KWSYS_IOS_NEED_OPERATORS_LL
 
-#include <stdio.h>  // sscanf, sprintf
-#include <string.h> // memchr
+#  include <stdio.h>  // sscanf, sprintf
+#  include <string.h> // memchr
 
-#if defined(_MAX_INT_DIG)
-#define KWSYS_IOS_INT64_MAX_DIG _MAX_INT_DIG
-#else
-#define KWSYS_IOS_INT64_MAX_DIG 32
-#endif
+#  if defined(_MAX_INT_DIG)
+#    define KWSYS_IOS_INT64_MAX_DIG _MAX_INT_DIG
+#  else
+#    define KWSYS_IOS_INT64_MAX_DIG 32
+#  endif
 
 namespace KWSYS_NAMESPACE {
 
@@ -118,13 +118,13 @@ std::istream& IOStreamScanTemplate(std::istream& is, T& value, char type)
     try {
       // Copy the string to a buffer and construct the format string.
       char buffer[KWSYS_IOS_INT64_MAX_DIG];
-#if defined(_MSC_VER)
+#  if defined(_MSC_VER)
       char format[] = "%I64_";
       const int typeIndex = 4;
-#else
+#  else
       char format[] = "%ll_";
       const int typeIndex = 3;
-#endif
+#  endif
       switch (IOStreamScanStream(is, buffer)) {
         case 8:
           format[typeIndex] = 'o';
@@ -177,14 +177,14 @@ std::ostream& IOStreamPrintTemplate(std::ostream& os, T value, char type)
       if (os.flags() & std::ios_base::showbase) {
         *f++ = '#';
       }
-#if defined(_MSC_VER)
+#  if defined(_MSC_VER)
       *f++ = 'I';
       *f++ = '6';
       *f++ = '4';
-#else
+#  else
       *f++ = 'l';
       *f++ = 'l';
-#endif
+#  endif
       long bflags = os.flags() & std::ios_base::basefield;
       if (bflags == std::ios_base::oct) {
         *f++ = 'o';
@@ -209,7 +209,7 @@ std::ostream& IOStreamPrintTemplate(std::ostream& os, T value, char type)
   return os;
 }
 
-#if !KWSYS_IOS_HAS_ISTREAM_LONG_LONG
+#  if !KWSYS_IOS_HAS_ISTREAM_LONG_LONG
 // Implement input stream operator for IOStreamSLL.
 std::istream& IOStreamScan(std::istream& is, IOStreamSLL& value)
 {
@@ -221,9 +221,9 @@ std::istream& IOStreamScan(std::istream& is, IOStreamULL& value)
 {
   return IOStreamScanTemplate(is, value, 'u');
 }
-#endif
+#  endif
 
-#if !KWSYS_IOS_HAS_OSTREAM_LONG_LONG
+#  if !KWSYS_IOS_HAS_OSTREAM_LONG_LONG
 // Implement output stream operator for IOStreamSLL.
 std::ostream& IOStreamPrint(std::ostream& os, IOStreamSLL value)
 {
@@ -235,7 +235,7 @@ std::ostream& IOStreamPrint(std::ostream& os, IOStreamULL value)
 {
   return IOStreamPrintTemplate(os, value, 'u');
 }
-#endif
+#  endif
 
 } // namespace KWSYS_NAMESPACE
 
diff --git a/Source/kwsys/IOStream.hxx.in b/Source/kwsys/IOStream.hxx.in
index de3a2e634..db8a23ef5 100644
--- a/Source/kwsys/IOStream.hxx.in
+++ b/Source/kwsys/IOStream.hxx.in
@@ -7,7 +7,7 @@
 
 /* Define these macros temporarily to keep the code readable.  */
 #if !defined(KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
-#define kwsysEXPORT @KWSYS_NAMESPACE@_EXPORT
+#  define kwsysEXPORT @KWSYS_NAMESPACE@_EXPORT
 #endif
 
 /* Whether istream supports long long.  */
@@ -21,27 +21,27 @@
 /* Determine whether we need to define the streaming operators for
    long long or __int64.  */
 #if @KWSYS_USE_LONG_LONG@
-#if !@KWSYS_NAMESPACE@_IOS_HAS_ISTREAM_LONG_LONG ||                           \
-  !@KWSYS_NAMESPACE@_IOS_HAS_OSTREAM_LONG_LONG
-#define @KWSYS_NAMESPACE@_IOS_NEED_OPERATORS_LL 1
+#  if !@KWSYS_NAMESPACE@_IOS_HAS_ISTREAM_LONG_LONG ||                         \
+    !@KWSYS_NAMESPACE@_IOS_HAS_OSTREAM_LONG_LONG
+#    define @KWSYS_NAMESPACE@_IOS_NEED_OPERATORS_LL 1
 namespace @KWSYS_NAMESPACE@ {
 typedef long long IOStreamSLL;
 typedef unsigned long long IOStreamULL;
 }
-#endif
+#  endif
 #elif defined(_MSC_VER) && _MSC_VER < 1300
-#define @KWSYS_NAMESPACE@_IOS_NEED_OPERATORS_LL 1
+#  define @KWSYS_NAMESPACE@_IOS_NEED_OPERATORS_LL 1
 namespace @KWSYS_NAMESPACE@ {
 typedef __int64 IOStreamSLL;
 typedef unsigned __int64 IOStreamULL;
 }
 #endif
 #if !defined(@KWSYS_NAMESPACE@_IOS_NEED_OPERATORS_LL)
-#define @KWSYS_NAMESPACE@_IOS_NEED_OPERATORS_LL 0
+#  define @KWSYS_NAMESPACE@_IOS_NEED_OPERATORS_LL 0
 #endif
 
 #if @KWSYS_NAMESPACE@_IOS_NEED_OPERATORS_LL
-#if !@KWSYS_NAMESPACE@_IOS_HAS_ISTREAM_LONG_LONG
+#  if !@KWSYS_NAMESPACE@_IOS_HAS_ISTREAM_LONG_LONG
 
 /* Input stream operator implementation functions.  */
 namespace @KWSYS_NAMESPACE@ {
@@ -50,31 +50,31 @@ kwsysEXPORT std::istream& IOStreamScan(std::istream&, IOStreamULL&);
 }
 
 /* Provide input stream operator for long long.  */
-#if !defined(@KWSYS_NAMESPACE@_IOS_NO_ISTREAM_LONG_LONG) &&                   \
-  !defined(KWSYS_IOS_ISTREAM_LONG_LONG_DEFINED)
-#define KWSYS_IOS_ISTREAM_LONG_LONG_DEFINED
-#define @KWSYS_NAMESPACE@_IOS_ISTREAM_LONG_LONG_DEFINED
+#    if !defined(@KWSYS_NAMESPACE@_IOS_NO_ISTREAM_LONG_LONG) &&               \
+      !defined(KWSYS_IOS_ISTREAM_LONG_LONG_DEFINED)
+#      define KWSYS_IOS_ISTREAM_LONG_LONG_DEFINED
+#      define @KWSYS_NAMESPACE@_IOS_ISTREAM_LONG_LONG_DEFINED
 inline std::istream& operator>>(std::istream& is,
                                 @KWSYS_NAMESPACE@::IOStreamSLL& value)
 {
   return @KWSYS_NAMESPACE@::IOStreamScan(is, value);
 }
-#endif
+#    endif
 
 /* Provide input stream operator for unsigned long long.  */
-#if !defined(@KWSYS_NAMESPACE@_IOS_NO_ISTREAM_UNSIGNED_LONG_LONG) &&          \
-  !defined(KWSYS_IOS_ISTREAM_UNSIGNED_LONG_LONG_DEFINED)
-#define KWSYS_IOS_ISTREAM_UNSIGNED_LONG_LONG_DEFINED
-#define @KWSYS_NAMESPACE@_IOS_ISTREAM_UNSIGNED_LONG_LONG_DEFINED
+#    if !defined(@KWSYS_NAMESPACE@_IOS_NO_ISTREAM_UNSIGNED_LONG_LONG) &&      \
+      !defined(KWSYS_IOS_ISTREAM_UNSIGNED_LONG_LONG_DEFINED)
+#      define KWSYS_IOS_ISTREAM_UNSIGNED_LONG_LONG_DEFINED
+#      define @KWSYS_NAMESPACE@_IOS_ISTREAM_UNSIGNED_LONG_LONG_DEFINED
 inline std::istream& operator>>(std::istream& is,
                                 @KWSYS_NAMESPACE@::IOStreamULL& value)
 {
   return @KWSYS_NAMESPACE@::IOStreamScan(is, value);
 }
-#endif
-#endif /* !@KWSYS_NAMESPACE@_IOS_HAS_ISTREAM_LONG_LONG */
+#    endif
+#  endif /* !@KWSYS_NAMESPACE@_IOS_HAS_ISTREAM_LONG_LONG */
 
-#if !@KWSYS_NAMESPACE@_IOS_HAS_OSTREAM_LONG_LONG
+#  if !@KWSYS_NAMESPACE@_IOS_HAS_OSTREAM_LONG_LONG
 
 /* Output stream operator implementation functions.  */
 namespace @KWSYS_NAMESPACE@ {
@@ -83,44 +83,44 @@ kwsysEXPORT std::ostream& IOStreamPrint(std::ostream&, IOStreamULL);
 }
 
 /* Provide output stream operator for long long.  */
-#if !defined(@KWSYS_NAMESPACE@_IOS_NO_OSTREAM_LONG_LONG) &&                   \
-  !defined(KWSYS_IOS_OSTREAM_LONG_LONG_DEFINED)
-#define KWSYS_IOS_OSTREAM_LONG_LONG_DEFINED
-#define @KWSYS_NAMESPACE@_IOS_OSTREAM_LONG_LONG_DEFINED
+#    if !defined(@KWSYS_NAMESPACE@_IOS_NO_OSTREAM_LONG_LONG) &&               \
+      !defined(KWSYS_IOS_OSTREAM_LONG_LONG_DEFINED)
+#      define KWSYS_IOS_OSTREAM_LONG_LONG_DEFINED
+#      define @KWSYS_NAMESPACE@_IOS_OSTREAM_LONG_LONG_DEFINED
 inline std::ostream& operator<<(std::ostream& os,
                                 @KWSYS_NAMESPACE@::IOStreamSLL value)
 {
   return @KWSYS_NAMESPACE@::IOStreamPrint(os, value);
 }
-#endif
+#    endif
 
 /* Provide output stream operator for unsigned long long.  */
-#if !defined(@KWSYS_NAMESPACE@_IOS_NO_OSTREAM_UNSIGNED_LONG_LONG) &&          \
-  !defined(KWSYS_IOS_OSTREAM_UNSIGNED_LONG_LONG_DEFINED)
-#define KWSYS_IOS_OSTREAM_UNSIGNED_LONG_LONG_DEFINED
-#define @KWSYS_NAMESPACE@_IOS_OSTREAM_UNSIGNED_LONG_LONG_DEFINED
+#    if !defined(@KWSYS_NAMESPACE@_IOS_NO_OSTREAM_UNSIGNED_LONG_LONG) &&      \
+      !defined(KWSYS_IOS_OSTREAM_UNSIGNED_LONG_LONG_DEFINED)
+#      define KWSYS_IOS_OSTREAM_UNSIGNED_LONG_LONG_DEFINED
+#      define @KWSYS_NAMESPACE@_IOS_OSTREAM_UNSIGNED_LONG_LONG_DEFINED
 inline std::ostream& operator<<(std::ostream& os,
                                 @KWSYS_NAMESPACE@::IOStreamULL value)
 {
   return @KWSYS_NAMESPACE@::IOStreamPrint(os, value);
 }
-#endif
-#endif /* !@KWSYS_NAMESPACE@_IOS_HAS_OSTREAM_LONG_LONG */
-#endif /* @KWSYS_NAMESPACE@_IOS_NEED_OPERATORS_LL */
+#    endif
+#  endif /* !@KWSYS_NAMESPACE@_IOS_HAS_OSTREAM_LONG_LONG */
+#endif   /* @KWSYS_NAMESPACE@_IOS_NEED_OPERATORS_LL */
 
 /* Undefine temporary macros.  */
 #if !defined(KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
-#undef kwsysEXPORT
+#  undef kwsysEXPORT
 #endif
 
 /* If building a C++ file in kwsys itself, give the source file
    access to the macros without a configured namespace.  */
 #if defined(KWSYS_NAMESPACE)
-#define KWSYS_IOS_HAS_ISTREAM_LONG_LONG                                       \
-  @KWSYS_NAMESPACE@_IOS_HAS_ISTREAM_LONG_LONG
-#define KWSYS_IOS_HAS_OSTREAM_LONG_LONG                                       \
-  @KWSYS_NAMESPACE@_IOS_HAS_OSTREAM_LONG_LONG
-#define KWSYS_IOS_NEED_OPERATORS_LL @KWSYS_NAMESPACE@_IOS_NEED_OPERATORS_LL
+#  define KWSYS_IOS_HAS_ISTREAM_LONG_LONG                                     \
+    @KWSYS_NAMESPACE@_IOS_HAS_ISTREAM_LONG_LONG
+#  define KWSYS_IOS_HAS_OSTREAM_LONG_LONG                                     \
+    @KWSYS_NAMESPACE@_IOS_HAS_OSTREAM_LONG_LONG
+#  define KWSYS_IOS_NEED_OPERATORS_LL @KWSYS_NAMESPACE@_IOS_NEED_OPERATORS_LL
 #endif
 
 #endif
diff --git a/Source/kwsys/MD5.c b/Source/kwsys/MD5.c
index 3188fb67a..97cf9ba68 100644
--- a/Source/kwsys/MD5.c
+++ b/Source/kwsys/MD5.c
@@ -6,7 +6,7 @@
 /* Work-around CMake dependency scanning limitation.  This must
    duplicate the above list of headers.  */
 #if 0
-#include "MD5.h.in"
+#  include "MD5.h.in"
 #endif
 
 #include <stddef.h> /* size_t */
@@ -19,8 +19,8 @@
    implementation file.  */
 
 #if defined(__clang__) && !defined(__INTEL_COMPILER)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wcast-align"
+#  pragma clang diagnostic push
+#  pragma clang diagnostic ignored "-Wcast-align"
 #endif
 
 /*
@@ -98,9 +98,9 @@ typedef struct md5_state_s
 
 #undef BYTE_ORDER /* 1 = big-endian, -1 = little-endian, 0 = unknown */
 #ifdef ARCH_IS_BIG_ENDIAN
-#define BYTE_ORDER (ARCH_IS_BIG_ENDIAN ? 1 : -1)
+#  define BYTE_ORDER (ARCH_IS_BIG_ENDIAN ? 1 : -1)
 #else
-#define BYTE_ORDER 0
+#  define BYTE_ORDER 0
 #endif
 
 #define T_MASK ((md5_word_t)~0)
@@ -222,11 +222,11 @@ static void md5_process(md5_state_t* pms, const md5_byte_t* data /*[64]*/)
       const md5_byte_t* xp = data;
       int i;
 
-#if BYTE_ORDER == 0
+#  if BYTE_ORDER == 0
       X = xbuf; /* (dynamic only) */
-#else
-#define xbuf X /* (static only) */
-#endif
+#  else
+#    define xbuf X /* (static only) */
+#  endif
       for (i = 0; i < 16; ++i, xp += 4)
         xbuf[i] =
           (md5_word_t)(xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24));
@@ -420,7 +420,7 @@ static void md5_finish(md5_state_t* pms, md5_byte_t digest[16])
 }
 
 #if defined(__clang__) && !defined(__INTEL_COMPILER)
-#pragma clang diagnostic pop
+#  pragma clang diagnostic pop
 #endif
 
 /* Wrap up the MD5 state in our opaque structure.  */
diff --git a/Source/kwsys/MD5.h.in b/Source/kwsys/MD5.h.in
index c257f7f9a..7646f1297 100644
--- a/Source/kwsys/MD5.h.in
+++ b/Source/kwsys/MD5.h.in
@@ -10,19 +10,19 @@
    not visible to user code.  Use kwsysHeaderDump.pl to reproduce
    these macros after making changes to the interface.  */
 #if !defined(KWSYS_NAMESPACE)
-#define kwsys_ns(x) @KWSYS_NAMESPACE@##x
-#define kwsysEXPORT @KWSYS_NAMESPACE@_EXPORT
+#  define kwsys_ns(x) @KWSYS_NAMESPACE@##x
+#  define kwsysEXPORT @KWSYS_NAMESPACE@_EXPORT
 #endif
 #if !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
-#define kwsysMD5 kwsys_ns(MD5)
-#define kwsysMD5_s kwsys_ns(MD5_s)
-#define kwsysMD5_New kwsys_ns(MD5_New)
-#define kwsysMD5_Delete kwsys_ns(MD5_Delete)
-#define kwsysMD5_Initialize kwsys_ns(MD5_Initialize)
-#define kwsysMD5_Append kwsys_ns(MD5_Append)
-#define kwsysMD5_Finalize kwsys_ns(MD5_Finalize)
-#define kwsysMD5_FinalizeHex kwsys_ns(MD5_FinalizeHex)
-#define kwsysMD5_DigestToHex kwsys_ns(MD5_DigestToHex)
+#  define kwsysMD5 kwsys_ns(MD5)
+#  define kwsysMD5_s kwsys_ns(MD5_s)
+#  define kwsysMD5_New kwsys_ns(MD5_New)
+#  define kwsysMD5_Delete kwsys_ns(MD5_Delete)
+#  define kwsysMD5_Initialize kwsys_ns(MD5_Initialize)
+#  define kwsysMD5_Append kwsys_ns(MD5_Append)
+#  define kwsysMD5_Finalize kwsys_ns(MD5_Finalize)
+#  define kwsysMD5_FinalizeHex kwsys_ns(MD5_FinalizeHex)
+#  define kwsysMD5_DigestToHex kwsys_ns(MD5_DigestToHex)
 #endif
 
 #if defined(__cplusplus)
@@ -79,19 +79,19 @@ kwsysEXPORT void kwsysMD5_DigestToHex(unsigned char const digest[16],
 /* If we are building a kwsys .c or .cxx file, let it use these macros.
    Otherwise, undefine them to keep the namespace clean.  */
 #if !defined(KWSYS_NAMESPACE)
-#undef kwsys_ns
-#undef kwsysEXPORT
-#if !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
-#undef kwsysMD5
-#undef kwsysMD5_s
-#undef kwsysMD5_New
-#undef kwsysMD5_Delete
-#undef kwsysMD5_Initialize
-#undef kwsysMD5_Append
-#undef kwsysMD5_Finalize
-#undef kwsysMD5_FinalizeHex
-#undef kwsysMD5_DigestToHex
-#endif
+#  undef kwsys_ns
+#  undef kwsysEXPORT
+#  if !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
+#    undef kwsysMD5
+#    undef kwsysMD5_s
+#    undef kwsysMD5_New
+#    undef kwsysMD5_Delete
+#    undef kwsysMD5_Initialize
+#    undef kwsysMD5_Append
+#    undef kwsysMD5_Finalize
+#    undef kwsysMD5_FinalizeHex
+#    undef kwsysMD5_DigestToHex
+#  endif
 #endif
 
 #endif
diff --git a/Source/kwsys/Process.h.in b/Source/kwsys/Process.h.in
index daf334a61..73ea9dbfc 100644
--- a/Source/kwsys/Process.h.in
+++ b/Source/kwsys/Process.h.in
@@ -10,75 +10,79 @@
    not visible to user code.  Use kwsysHeaderDump.pl to reproduce
    these macros after making changes to the interface.  */
 #if !defined(KWSYS_NAMESPACE)
-#define kwsys_ns(x) @KWSYS_NAMESPACE@##x
-#define kwsysEXPORT @KWSYS_NAMESPACE@_EXPORT
+#  define kwsys_ns(x) @KWSYS_NAMESPACE@##x
+#  define kwsysEXPORT @KWSYS_NAMESPACE@_EXPORT
 #endif
 #if !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
-#define kwsysProcess kwsys_ns(Process)
-#define kwsysProcess_s kwsys_ns(Process_s)
-#define kwsysProcess_New kwsys_ns(Process_New)
-#define kwsysProcess_Delete kwsys_ns(Process_Delete)
-#define kwsysProcess_SetCommand kwsys_ns(Process_SetCommand)
-#define kwsysProcess_AddCommand kwsys_ns(Process_AddCommand)
-#define kwsysProcess_SetTimeout kwsys_ns(Process_SetTimeout)
-#define kwsysProcess_SetWorkingDirectory kwsys_ns(Process_SetWorkingDirectory)
-#define kwsysProcess_SetPipeFile kwsys_ns(Process_SetPipeFile)
-#define kwsysProcess_SetPipeNative kwsys_ns(Process_SetPipeNative)
-#define kwsysProcess_SetPipeShared kwsys_ns(Process_SetPipeShared)
-#define kwsysProcess_Option_Detach kwsys_ns(Process_Option_Detach)
-#define kwsysProcess_Option_HideWindow kwsys_ns(Process_Option_HideWindow)
-#define kwsysProcess_Option_MergeOutput kwsys_ns(Process_Option_MergeOutput)
-#define kwsysProcess_Option_Verbatim kwsys_ns(Process_Option_Verbatim)
-#define kwsysProcess_Option_CreateProcessGroup                                \
-  kwsys_ns(Process_Option_CreateProcessGroup)
-#define kwsysProcess_GetOption kwsys_ns(Process_GetOption)
-#define kwsysProcess_SetOption kwsys_ns(Process_SetOption)
-#define kwsysProcess_Option_e kwsys_ns(Process_Option_e)
-#define kwsysProcess_State_Starting kwsys_ns(Process_State_Starting)
-#define kwsysProcess_State_Error kwsys_ns(Process_State_Error)
-#define kwsysProcess_State_Exception kwsys_ns(Process_State_Exception)
-#define kwsysProcess_State_Executing kwsys_ns(Process_State_Executing)
-#define kwsysProcess_State_Exited kwsys_ns(Process_State_Exited)
-#define kwsysProcess_State_Expired kwsys_ns(Process_State_Expired)
-#define kwsysProcess_State_Killed kwsys_ns(Process_State_Killed)
-#define kwsysProcess_State_Disowned kwsys_ns(Process_State_Disowned)
-#define kwsysProcess_State_e kwsys_ns(Process_State_e)
-#define kwsysProcess_Exception_None kwsys_ns(Process_Exception_None)
-#define kwsysProcess_Exception_Fault kwsys_ns(Process_Exception_Fault)
-#define kwsysProcess_Exception_Illegal kwsys_ns(Process_Exception_Illegal)
-#define kwsysProcess_Exception_Interrupt kwsys_ns(Process_Exception_Interrupt)
-#define kwsysProcess_Exception_Numerical kwsys_ns(Process_Exception_Numerical)
-#define kwsysProcess_Exception_Other kwsys_ns(Process_Exception_Other)
-#define kwsysProcess_Exception_e kwsys_ns(Process_Exception_e)
-#define kwsysProcess_GetState kwsys_ns(Process_GetState)
-#define kwsysProcess_GetExitException kwsys_ns(Process_GetExitException)
-#define kwsysProcess_GetExitCode kwsys_ns(Process_GetExitCode)
-#define kwsysProcess_GetExitValue kwsys_ns(Process_GetExitValue)
-#define kwsysProcess_GetErrorString kwsys_ns(Process_GetErrorString)
-#define kwsysProcess_GetExceptionString kwsys_ns(Process_GetExceptionString)
-#define kwsysProcess_GetStateByIndex kwsys_ns(Process_GetStateByIndex)
-#define kwsysProcess_GetExitExceptionByIndex                                  \
-  kwsys_ns(Process_GetExitExceptionByIndex)
-#define kwsysProcess_GetExitCodeByIndex kwsys_ns(Process_GetExitCodeByIndex)
-#define kwsysProcess_GetExitValueByIndex kwsys_ns(Process_GetExitValueByIndex)
-#define kwsysProcess_GetExceptionStringByIndex                                \
-  kwsys_ns(Process_GetExceptionStringByIndex)
-#define kwsysProcess_GetExitCodeByIndex kwsys_ns(Process_GetExitCodeByIndex)
-#define kwsysProcess_Execute kwsys_ns(Process_Execute)
-#define kwsysProcess_Disown kwsys_ns(Process_Disown)
-#define kwsysProcess_WaitForData kwsys_ns(Process_WaitForData)
-#define kwsysProcess_Pipes_e kwsys_ns(Process_Pipes_e)
-#define kwsysProcess_Pipe_None kwsys_ns(Process_Pipe_None)
-#define kwsysProcess_Pipe_STDIN kwsys_ns(Process_Pipe_STDIN)
-#define kwsysProcess_Pipe_STDOUT kwsys_ns(Process_Pipe_STDOUT)
-#define kwsysProcess_Pipe_STDERR kwsys_ns(Process_Pipe_STDERR)
-#define kwsysProcess_Pipe_Timeout kwsys_ns(Process_Pipe_Timeout)
-#define kwsysProcess_Pipe_Handle kwsys_ns(Process_Pipe_Handle)
-#define kwsysProcess_WaitForExit kwsys_ns(Process_WaitForExit)
-#define kwsysProcess_Interrupt kwsys_ns(Process_Interrupt)
-#define kwsysProcess_Kill kwsys_ns(Process_Kill)
-#define kwsysProcess_KillPID kwsys_ns(Process_KillPID)
-#define kwsysProcess_ResetStartTime kwsys_ns(Process_ResetStartTime)
+#  define kwsysProcess kwsys_ns(Process)
+#  define kwsysProcess_s kwsys_ns(Process_s)
+#  define kwsysProcess_New kwsys_ns(Process_New)
+#  define kwsysProcess_Delete kwsys_ns(Process_Delete)
+#  define kwsysProcess_SetCommand kwsys_ns(Process_SetCommand)
+#  define kwsysProcess_AddCommand kwsys_ns(Process_AddCommand)
+#  define kwsysProcess_SetTimeout kwsys_ns(Process_SetTimeout)
+#  define kwsysProcess_SetWorkingDirectory                                    \
+    kwsys_ns(Process_SetWorkingDirectory)
+#  define kwsysProcess_SetPipeFile kwsys_ns(Process_SetPipeFile)
+#  define kwsysProcess_SetPipeNative kwsys_ns(Process_SetPipeNative)
+#  define kwsysProcess_SetPipeShared kwsys_ns(Process_SetPipeShared)
+#  define kwsysProcess_Option_Detach kwsys_ns(Process_Option_Detach)
+#  define kwsysProcess_Option_HideWindow kwsys_ns(Process_Option_HideWindow)
+#  define kwsysProcess_Option_MergeOutput kwsys_ns(Process_Option_MergeOutput)
+#  define kwsysProcess_Option_Verbatim kwsys_ns(Process_Option_Verbatim)
+#  define kwsysProcess_Option_CreateProcessGroup                              \
+    kwsys_ns(Process_Option_CreateProcessGroup)
+#  define kwsysProcess_GetOption kwsys_ns(Process_GetOption)
+#  define kwsysProcess_SetOption kwsys_ns(Process_SetOption)
+#  define kwsysProcess_Option_e kwsys_ns(Process_Option_e)
+#  define kwsysProcess_State_Starting kwsys_ns(Process_State_Starting)
+#  define kwsysProcess_State_Error kwsys_ns(Process_State_Error)
+#  define kwsysProcess_State_Exception kwsys_ns(Process_State_Exception)
+#  define kwsysProcess_State_Executing kwsys_ns(Process_State_Executing)
+#  define kwsysProcess_State_Exited kwsys_ns(Process_State_Exited)
+#  define kwsysProcess_State_Expired kwsys_ns(Process_State_Expired)
+#  define kwsysProcess_State_Killed kwsys_ns(Process_State_Killed)
+#  define kwsysProcess_State_Disowned kwsys_ns(Process_State_Disowned)
+#  define kwsysProcess_State_e kwsys_ns(Process_State_e)
+#  define kwsysProcess_Exception_None kwsys_ns(Process_Exception_None)
+#  define kwsysProcess_Exception_Fault kwsys_ns(Process_Exception_Fault)
+#  define kwsysProcess_Exception_Illegal kwsys_ns(Process_Exception_Illegal)
+#  define kwsysProcess_Exception_Interrupt                                    \
+    kwsys_ns(Process_Exception_Interrupt)
+#  define kwsysProcess_Exception_Numerical                                    \
+    kwsys_ns(Process_Exception_Numerical)
+#  define kwsysProcess_Exception_Other kwsys_ns(Process_Exception_Other)
+#  define kwsysProcess_Exception_e kwsys_ns(Process_Exception_e)
+#  define kwsysProcess_GetState kwsys_ns(Process_GetState)
+#  define kwsysProcess_GetExitException kwsys_ns(Process_GetExitException)
+#  define kwsysProcess_GetExitCode kwsys_ns(Process_GetExitCode)
+#  define kwsysProcess_GetExitValue kwsys_ns(Process_GetExitValue)
+#  define kwsysProcess_GetErrorString kwsys_ns(Process_GetErrorString)
+#  define kwsysProcess_GetExceptionString kwsys_ns(Process_GetExceptionString)
+#  define kwsysProcess_GetStateByIndex kwsys_ns(Process_GetStateByIndex)
+#  define kwsysProcess_GetExitExceptionByIndex                                \
+    kwsys_ns(Process_GetExitExceptionByIndex)
+#  define kwsysProcess_GetExitCodeByIndex kwsys_ns(Process_GetExitCodeByIndex)
+#  define kwsysProcess_GetExitValueByIndex                                    \
+    kwsys_ns(Process_GetExitValueByIndex)
+#  define kwsysProcess_GetExceptionStringByIndex                              \
+    kwsys_ns(Process_GetExceptionStringByIndex)
+#  define kwsysProcess_GetExitCodeByIndex kwsys_ns(Process_GetExitCodeByIndex)
+#  define kwsysProcess_Execute kwsys_ns(Process_Execute)
+#  define kwsysProcess_Disown kwsys_ns(Process_Disown)
+#  define kwsysProcess_WaitForData kwsys_ns(Process_WaitForData)
+#  define kwsysProcess_Pipes_e kwsys_ns(Process_Pipes_e)
+#  define kwsysProcess_Pipe_None kwsys_ns(Process_Pipe_None)
+#  define kwsysProcess_Pipe_STDIN kwsys_ns(Process_Pipe_STDIN)
+#  define kwsysProcess_Pipe_STDOUT kwsys_ns(Process_Pipe_STDOUT)
+#  define kwsysProcess_Pipe_STDERR kwsys_ns(Process_Pipe_STDERR)
+#  define kwsysProcess_Pipe_Timeout kwsys_ns(Process_Pipe_Timeout)
+#  define kwsysProcess_Pipe_Handle kwsys_ns(Process_Pipe_Handle)
+#  define kwsysProcess_WaitForExit kwsys_ns(Process_WaitForExit)
+#  define kwsysProcess_Interrupt kwsys_ns(Process_Interrupt)
+#  define kwsysProcess_Kill kwsys_ns(Process_Kill)
+#  define kwsysProcess_KillPID kwsys_ns(Process_KillPID)
+#  define kwsysProcess_ResetStartTime kwsys_ns(Process_ResetStartTime)
 #endif
 
 #if defined(__cplusplus)
@@ -307,13 +311,13 @@ kwsysEXPORT const char* kwsysProcess_GetErrorString(kwsysProcess* cp);
 kwsysEXPORT const char* kwsysProcess_GetExceptionString(kwsysProcess* cp);
 
 /**
-* Get the current state of the Process instance.  Possible states are:
-*
-*  kwsysProcess_StateByIndex_Starting  = Execute has not yet been called.
-*  kwsysProcess_StateByIndex_Exception = Child process exited abnormally.
-*  kwsysProcess_StateByIndex_Exited    = Child process exited normally.
-*  kwsysProcess_StateByIndex_Error     = Error getting the child return code.
-*/
+ * Get the current state of the Process instance.  Possible states are:
+ *
+ *  kwsysProcess_StateByIndex_Starting  = Execute has not yet been called.
+ *  kwsysProcess_StateByIndex_Exception = Child process exited abnormally.
+ *  kwsysProcess_StateByIndex_Exited    = Child process exited normally.
+ *  kwsysProcess_StateByIndex_Error     = Error getting the child return code.
+ */
 kwsysEXPORT int kwsysProcess_GetStateByIndex(kwsysProcess* cp, int idx);
 enum kwsysProcess_StateByIndex_e
 {
@@ -324,46 +328,46 @@ enum kwsysProcess_StateByIndex_e
 };
 
 /**
-* When GetState returns "Exception", this method returns a
-* platform-independent description of the exceptional behavior that
-* caused the child to terminate abnormally.  Possible exceptions are:
-*
-*  kwsysProcess_Exception_None      = No exceptional behavior occurred.
-*  kwsysProcess_Exception_Fault     = Child crashed with a memory fault.
-*  kwsysProcess_Exception_Illegal   = Child crashed with an illegal
-*                                     instruction.
-*  kwsysProcess_Exception_Interrupt = Child was interrupted by user
-*                                     (Cntl-C/Break).
-*  kwsysProcess_Exception_Numerical = Child crashed with a numerical
-*                                     exception.
-*  kwsysProcess_Exception_Other     = Child terminated for another reason.
-*/
+ * When GetState returns "Exception", this method returns a
+ * platform-independent description of the exceptional behavior that
+ * caused the child to terminate abnormally.  Possible exceptions are:
+ *
+ *  kwsysProcess_Exception_None      = No exceptional behavior occurred.
+ *  kwsysProcess_Exception_Fault     = Child crashed with a memory fault.
+ *  kwsysProcess_Exception_Illegal   = Child crashed with an illegal
+ *                                     instruction.
+ *  kwsysProcess_Exception_Interrupt = Child was interrupted by user
+ *                                     (Cntl-C/Break).
+ *  kwsysProcess_Exception_Numerical = Child crashed with a numerical
+ *                                     exception.
+ *  kwsysProcess_Exception_Other     = Child terminated for another reason.
+ */
 kwsysEXPORT int kwsysProcess_GetExitExceptionByIndex(kwsysProcess* cp,
                                                      int idx);
 
 /**
-* When GetState returns "Exited" or "Exception", this method returns
-* the platform-specific raw exit code of the process.  UNIX platforms
-* should use WIFEXITED/WEXITSTATUS and WIFSIGNALED/WTERMSIG to access
-* this value.  Windows users should compare the value to the various
-* EXCEPTION_* values.
-*
-* If GetState returns "Exited", use GetExitValue to get the
-* platform-independent child return value.
-*/
+ * When GetState returns "Exited" or "Exception", this method returns
+ * the platform-specific raw exit code of the process.  UNIX platforms
+ * should use WIFEXITED/WEXITSTATUS and WIFSIGNALED/WTERMSIG to access
+ * this value.  Windows users should compare the value to the various
+ * EXCEPTION_* values.
+ *
+ * If GetState returns "Exited", use GetExitValue to get the
+ * platform-independent child return value.
+ */
 kwsysEXPORT int kwsysProcess_GetExitCodeByIndex(kwsysProcess* cp, int idx);
 
 /**
-* When GetState returns "Exited", this method returns the child's
-* platform-independent exit code (such as the value returned by the
-* child's main).
-*/
+ * When GetState returns "Exited", this method returns the child's
+ * platform-independent exit code (such as the value returned by the
+ * child's main).
+ */
 kwsysEXPORT int kwsysProcess_GetExitValueByIndex(kwsysProcess* cp, int idx);
 
 /**
-* When GetState returns "Exception", this method returns a string
-* describing the problem.  Otherwise, it returns NULL.
-*/
+ * When GetState returns "Exception", this method returns a string
+ * describing the problem.  Otherwise, it returns NULL.
+ */
 kwsysEXPORT const char* kwsysProcess_GetExceptionStringByIndex(
   kwsysProcess* cp, int idx);
 
@@ -476,65 +480,65 @@ kwsysEXPORT void kwsysProcess_ResetStartTime(kwsysProcess* cp);
 /* If we are building a kwsys .c or .cxx file, let it use these macros.
    Otherwise, undefine them to keep the namespace clean.  */
 #if !defined(KWSYS_NAMESPACE)
-#undef kwsys_ns
-#undef kwsysEXPORT
-#if !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
-#undef kwsysProcess
-#undef kwsysProcess_s
-#undef kwsysProcess_New
-#undef kwsysProcess_Delete
-#undef kwsysProcess_SetCommand
-#undef kwsysProcess_AddCommand
-#undef kwsysProcess_SetTimeout
-#undef kwsysProcess_SetWorkingDirectory
-#undef kwsysProcess_SetPipeFile
-#undef kwsysProcess_SetPipeNative
-#undef kwsysProcess_SetPipeShared
-#undef kwsysProcess_Option_Detach
-#undef kwsysProcess_Option_HideWindow
-#undef kwsysProcess_Option_MergeOutput
-#undef kwsysProcess_Option_Verbatim
-#undef kwsysProcess_Option_CreateProcessGroup
-#undef kwsysProcess_GetOption
-#undef kwsysProcess_SetOption
-#undef kwsysProcess_Option_e
-#undef kwsysProcess_State_Starting
-#undef kwsysProcess_State_Error
-#undef kwsysProcess_State_Exception
-#undef kwsysProcess_State_Executing
-#undef kwsysProcess_State_Exited
-#undef kwsysProcess_State_Expired
-#undef kwsysProcess_State_Killed
-#undef kwsysProcess_State_Disowned
-#undef kwsysProcess_GetState
-#undef kwsysProcess_State_e
-#undef kwsysProcess_Exception_None
-#undef kwsysProcess_Exception_Fault
-#undef kwsysProcess_Exception_Illegal
-#undef kwsysProcess_Exception_Interrupt
-#undef kwsysProcess_Exception_Numerical
-#undef kwsysProcess_Exception_Other
-#undef kwsysProcess_GetExitException
-#undef kwsysProcess_Exception_e
-#undef kwsysProcess_GetExitCode
-#undef kwsysProcess_GetExitValue
-#undef kwsysProcess_GetErrorString
-#undef kwsysProcess_GetExceptionString
-#undef kwsysProcess_Execute
-#undef kwsysProcess_Disown
-#undef kwsysProcess_WaitForData
-#undef kwsysProcess_Pipes_e
-#undef kwsysProcess_Pipe_None
-#undef kwsysProcess_Pipe_STDIN
-#undef kwsysProcess_Pipe_STDOUT
-#undef kwsysProcess_Pipe_STDERR
-#undef kwsysProcess_Pipe_Timeout
-#undef kwsysProcess_Pipe_Handle
-#undef kwsysProcess_WaitForExit
-#undef kwsysProcess_Interrupt
-#undef kwsysProcess_Kill
-#undef kwsysProcess_ResetStartTime
-#endif
+#  undef kwsys_ns
+#  undef kwsysEXPORT
+#  if !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
+#    undef kwsysProcess
+#    undef kwsysProcess_s
+#    undef kwsysProcess_New
+#    undef kwsysProcess_Delete
+#    undef kwsysProcess_SetCommand
+#    undef kwsysProcess_AddCommand
+#    undef kwsysProcess_SetTimeout
+#    undef kwsysProcess_SetWorkingDirectory
+#    undef kwsysProcess_SetPipeFile
+#    undef kwsysProcess_SetPipeNative
+#    undef kwsysProcess_SetPipeShared
+#    undef kwsysProcess_Option_Detach
+#    undef kwsysProcess_Option_HideWindow
+#    undef kwsysProcess_Option_MergeOutput
+#    undef kwsysProcess_Option_Verbatim
+#    undef kwsysProcess_Option_CreateProcessGroup
+#    undef kwsysProcess_GetOption
+#    undef kwsysProcess_SetOption
+#    undef kwsysProcess_Option_e
+#    undef kwsysProcess_State_Starting
+#    undef kwsysProcess_State_Error
+#    undef kwsysProcess_State_Exception
+#    undef kwsysProcess_State_Executing
+#    undef kwsysProcess_State_Exited
+#    undef kwsysProcess_State_Expired
+#    undef kwsysProcess_State_Killed
+#    undef kwsysProcess_State_Disowned
+#    undef kwsysProcess_GetState
+#    undef kwsysProcess_State_e
+#    undef kwsysProcess_Exception_None
+#    undef kwsysProcess_Exception_Fault
+#    undef kwsysProcess_Exception_Illegal
+#    undef kwsysProcess_Exception_Interrupt
+#    undef kwsysProcess_Exception_Numerical
+#    undef kwsysProcess_Exception_Other
+#    undef kwsysProcess_GetExitException
+#    undef kwsysProcess_Exception_e
+#    undef kwsysProcess_GetExitCode
+#    undef kwsysProcess_GetExitValue
+#    undef kwsysProcess_GetErrorString
+#    undef kwsysProcess_GetExceptionString
+#    undef kwsysProcess_Execute
+#    undef kwsysProcess_Disown
+#    undef kwsysProcess_WaitForData
+#    undef kwsysProcess_Pipes_e
+#    undef kwsysProcess_Pipe_None
+#    undef kwsysProcess_Pipe_STDIN
+#    undef kwsysProcess_Pipe_STDOUT
+#    undef kwsysProcess_Pipe_STDERR
+#    undef kwsysProcess_Pipe_Timeout
+#    undef kwsysProcess_Pipe_Handle
+#    undef kwsysProcess_WaitForExit
+#    undef kwsysProcess_Interrupt
+#    undef kwsysProcess_Kill
+#    undef kwsysProcess_ResetStartTime
+#  endif
 #endif
 
 #endif
diff --git a/Source/kwsys/ProcessUNIX.c b/Source/kwsys/ProcessUNIX.c
index 1e80b39cb..094c2ee23 100644
--- a/Source/kwsys/ProcessUNIX.c
+++ b/Source/kwsys/ProcessUNIX.c
@@ -7,8 +7,8 @@
 /* Work-around CMake dependency scanning limitation.  This must
    duplicate the above list of headers.  */
 #if 0
-#include "Process.h.in"
-#include "System.h.in"
+#  include "Process.h.in"
+#  include "System.h.in"
 #endif
 
 /*
@@ -40,7 +40,7 @@ do.
 #if defined(__CYGWIN__)
 /* Increase the file descriptor limit for select() before including
    related system headers. (Default: 64) */
-#define FD_SETSIZE 16384
+#  define FD_SETSIZE 16384
 #endif
 
 #include <assert.h>    /* assert */
@@ -61,9 +61,9 @@ do.
 #include <unistd.h>    /* pipe, close, fork, execvp, select, _exit */
 
 #if defined(__VMS)
-#define KWSYSPE_VMS_NONBLOCK , O_NONBLOCK
+#  define KWSYSPE_VMS_NONBLOCK , O_NONBLOCK
 #else
-#define KWSYSPE_VMS_NONBLOCK
+#  define KWSYSPE_VMS_NONBLOCK
 #endif
 
 #if defined(KWSYS_C_HAS_PTRDIFF_T) && KWSYS_C_HAS_PTRDIFF_T
@@ -80,13 +80,13 @@ typedef int kwsysProcess_ssize_t;
 
 #if defined(__BEOS__) && !defined(__ZETA__)
 /* BeOS 5 doesn't have usleep(), but it has snooze(), which is identical. */
-#include <be/kernel/OS.h>
+#  include <be/kernel/OS.h>
 static inline void kwsysProcess_usleep(unsigned int msec)
 {
   snooze(msec);
 }
 #else
-#define kwsysProcess_usleep usleep
+#  define kwsysProcess_usleep usleep
 #endif
 
 /*
@@ -101,12 +101,12 @@ static inline void kwsysProcess_usleep(unsigned int msec)
  */
 #if !defined(__BEOS__) && !defined(__VMS) && !defined(__MINT__) &&            \
   !defined(KWSYSPE_USE_SELECT)
-#define KWSYSPE_USE_SELECT 1
+#  define KWSYSPE_USE_SELECT 1
 #endif
 
 /* Some platforms do not have siginfo on their signal handlers.  */
 #if defined(SA_SIGINFO) && !defined(__BEOS__)
-#define KWSYSPE_USE_SIGINFO 1
+#  define KWSYSPE_USE_SIGINFO 1
 #endif
 
 /* The number of pipes for the child's output.  The standard stdout
@@ -1266,21 +1266,21 @@ static int kwsysProcessWaitForPipe(kwsysProcess* cp, char** data, int* length,
       } else if (n == 0) /* EOF */
       {
 /* We are done reading from this pipe.  */
-#if defined(__VMS)
+#  if defined(__VMS)
         if (!cp->CommandsLeft)
-#endif
+#  endif
         {
           kwsysProcessCleanupDescriptor(&cp->PipeReadEnds[i]);
           --cp->PipesLeft;
         }
       } else if (n < 0) /* error */
       {
-#if defined(__VMS)
+#  if defined(__VMS)
         if (!cp->CommandsLeft) {
           kwsysProcessCleanupDescriptor(&cp->PipeReadEnds[i]);
           --cp->PipesLeft;
         } else
-#endif
+#  endif
           if ((errno != EINTR) && (errno != EAGAIN)) {
           strncpy(cp->ErrorMessage, strerror(errno), KWSYSPE_PIPE_BUFFER_SIZE);
           /* Kill the children now.  */
@@ -1471,12 +1471,12 @@ static void kwsysProcessVolatileFree(volatile void* p)
 /* clang has made it impossible to free memory that points to volatile
    without first using special pragmas to disable a warning...  */
 #if defined(__clang__) && !defined(__INTEL_COMPILER)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wcast-qual"
+#  pragma clang diagnostic push
+#  pragma clang diagnostic ignored "-Wcast-qual"
 #endif
   free((void*)p); /* The cast will silence most compilers, but not clang.  */
 #if defined(__clang__) && !defined(__INTEL_COMPILER)
-#pragma clang diagnostic pop
+#  pragma clang diagnostic pop
 #endif
 }
 
@@ -2098,11 +2098,11 @@ static void kwsysProcessSetExitExceptionByIndex(kwsysProcess* cp, int sig,
       break;
 #endif
 #ifdef SIGBUS
-#if !defined(SIGSEGV) || SIGBUS != SIGSEGV
+#  if !defined(SIGSEGV) || SIGBUS != SIGSEGV
     case SIGBUS:
       KWSYSPE_CASE(Fault, "Bus error");
       break;
-#endif
+#  endif
 #endif
 #ifdef SIGFPE
     case SIGFPE:
@@ -2150,11 +2150,11 @@ static void kwsysProcessSetExitExceptionByIndex(kwsysProcess* cp, int sig,
       break;
 #endif
 #ifdef SIGIOT
-#if !defined(SIGABRT) || SIGIOT != SIGABRT
+#  if !defined(SIGABRT) || SIGIOT != SIGABRT
     case SIGIOT:
       KWSYSPE_CASE(Other, "SIGIOT");
       break;
-#endif
+#  endif
 #endif
 #ifdef SIGUSR1
     case SIGUSR1:
@@ -2251,11 +2251,11 @@ static void kwsysProcessSetExitExceptionByIndex(kwsysProcess* cp, int sig,
       break;
 #endif
 #ifdef SIGIO
-#if !defined(SIGPOLL) || SIGIO != SIGPOLL
+#  if !defined(SIGPOLL) || SIGIO != SIGPOLL
     case SIGIO:
       KWSYSPE_CASE(Other, "SIGIO");
       break;
-#endif
+#  endif
 #endif
 #ifdef SIGPWR
     case SIGPWR:
@@ -2268,11 +2268,11 @@ static void kwsysProcessSetExitExceptionByIndex(kwsysProcess* cp, int sig,
       break;
 #endif
 #ifdef SIGUNUSED
-#if !defined(SIGSYS) || SIGUNUSED != SIGSYS
+#  if !defined(SIGSYS) || SIGUNUSED != SIGSYS
     case SIGUNUSED:
       KWSYSPE_CASE(Other, "SIGUNUSED");
       break;
-#endif
+#  endif
 #endif
     default:
       cp->ProcessResults[idx].ExitException = kwsysProcess_Exception_Other;
@@ -2468,21 +2468,21 @@ static pid_t kwsysProcessFork(kwsysProcess* cp,
    have two integers to store: the pid and then the ppid.  */
 #if defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__) ||       \
   defined(__OpenBSD__) || defined(__GLIBC__) || defined(__GNU__)
-#define KWSYSPE_PS_COMMAND "ps axo pid,ppid"
-#define KWSYSPE_PS_FORMAT "%d %d\n"
+#  define KWSYSPE_PS_COMMAND "ps axo pid,ppid"
+#  define KWSYSPE_PS_FORMAT "%d %d\n"
 #elif defined(__sun) && (defined(__SVR4) || defined(__svr4__)) /* Solaris */
-#define KWSYSPE_PS_COMMAND "ps -e -o pid,ppid"
-#define KWSYSPE_PS_FORMAT "%d %d\n"
+#  define KWSYSPE_PS_COMMAND "ps -e -o pid,ppid"
+#  define KWSYSPE_PS_FORMAT "%d %d\n"
 #elif defined(__hpux) || defined(__sun__) || defined(__sgi) ||                \
   defined(_AIX) || defined(__sparc)
-#define KWSYSPE_PS_COMMAND "ps -ef"
-#define KWSYSPE_PS_FORMAT "%*s %d %d %*[^\n]\n"
+#  define KWSYSPE_PS_COMMAND "ps -ef"
+#  define KWSYSPE_PS_FORMAT "%*s %d %d %*[^\n]\n"
 #elif defined(__QNX__)
-#define KWSYSPE_PS_COMMAND "ps -Af"
-#define KWSYSPE_PS_FORMAT "%*d %d %d %*[^\n]\n"
+#  define KWSYSPE_PS_COMMAND "ps -Af"
+#  define KWSYSPE_PS_FORMAT "%*d %d %d %*[^\n]\n"
 #elif defined(__CYGWIN__)
-#define KWSYSPE_PS_COMMAND "ps aux"
-#define KWSYSPE_PS_FORMAT "%d %d %*[^\n]\n"
+#  define KWSYSPE_PS_COMMAND "ps aux"
+#  define KWSYSPE_PS_FORMAT "%d %d %*[^\n]\n"
 #endif
 
 void kwsysProcess_KillPID(unsigned long process_id)
@@ -2509,13 +2509,13 @@ static void kwsysProcessKill(pid_t process_id)
 #if defined(__linux__) || defined(__CYGWIN__)
   /* First try using the /proc filesystem.  */
   if ((procdir = opendir("/proc")) != NULL) {
-#if defined(MAXPATHLEN)
+#  if defined(MAXPATHLEN)
     char fname[MAXPATHLEN];
-#elif defined(PATH_MAX)
+#  elif defined(PATH_MAX)
     char fname[PATH_MAX];
-#else
+#  else
     char fname[4096];
-#endif
+#  endif
     char buffer[KWSYSPE_PIPE_BUFFER_SIZE + 1];
     struct dirent* d;
 
@@ -2715,9 +2715,9 @@ static int kwsysProcessesAdd(kwsysProcess* cp)
 #if KWSYSPE_USE_SIGINFO
       newSigAction.sa_sigaction = kwsysProcessesSignalHandler;
       newSigAction.sa_flags = SA_NOCLDSTOP | SA_SIGINFO;
-#ifdef SA_RESTART
+#  ifdef SA_RESTART
       newSigAction.sa_flags |= SA_RESTART;
-#endif
+#  endif
 #else
       newSigAction.sa_handler = kwsysProcessesSignalHandler;
       newSigAction.sa_flags = SA_NOCLDSTOP;
@@ -2804,7 +2804,7 @@ static void kwsysProcessesSignalHandler(int signum
                                         ,
                                         siginfo_t* info, void* ucontext
 #endif
-                                        )
+)
 {
   int i, j, procStatus, old_errno = errno;
 #if KWSYSPE_USE_SIGINFO
diff --git a/Source/kwsys/ProcessWin32.c b/Source/kwsys/ProcessWin32.c
index 82fdc7478..9fa0cb12a 100644
--- a/Source/kwsys/ProcessWin32.c
+++ b/Source/kwsys/ProcessWin32.c
@@ -7,8 +7,8 @@
 /* Work-around CMake dependency scanning limitation.  This must
    duplicate the above list of headers.  */
 #if 0
-#include "Encoding.h.in"
-#include "Process.h.in"
+#  include "Encoding.h.in"
+#  include "Process.h.in"
 #endif
 
 /*
@@ -22,35 +22,35 @@ a UNIX-style select system call.
 */
 
 #ifdef _MSC_VER
-#pragma warning(push, 1)
+#  pragma warning(push, 1)
 #endif
 #include <windows.h> /* Windows API */
 #if defined(_MSC_VER) && _MSC_VER >= 1800
-#define KWSYS_WINDOWS_DEPRECATED_GetVersionEx
+#  define KWSYS_WINDOWS_DEPRECATED_GetVersionEx
 #endif
 #include <io.h>     /* _unlink */
 #include <stdio.h>  /* sprintf */
 #include <string.h> /* strlen, strdup */
 #ifdef __WATCOMC__
-#define _unlink unlink
+#  define _unlink unlink
 #endif
 
 #ifndef _MAX_FNAME
-#define _MAX_FNAME 4096
+#  define _MAX_FNAME 4096
 #endif
 #ifndef _MAX_PATH
-#define _MAX_PATH 4096
+#  define _MAX_PATH 4096
 #endif
 
 #ifdef _MSC_VER
-#pragma warning(pop)
-#pragma warning(disable : 4514)
-#pragma warning(disable : 4706)
+#  pragma warning(pop)
+#  pragma warning(disable : 4514)
+#  pragma warning(disable : 4706)
 #endif
 
 #if defined(__BORLANDC__)
-#pragma warn - 8004 /* assigned a value that is never used  */
-#pragma warn - 8060 /* Assignment inside if() condition.  */
+#  pragma warn - 8004 /* assigned a value that is never used  */
+#  pragma warn - 8060 /* Assignment inside if() condition.  */
 #endif
 
 /* There are pipes for the process pipeline's stdout and stderr.  */
@@ -63,14 +63,14 @@ a UNIX-style select system call.
 
 /* Debug output macro.  */
 #if 0
-#define KWSYSPE_DEBUG(x)                                                      \
-  ((void*)cp == (void*)0x00226DE0                                             \
-     ? (fprintf(stderr, "%d/%p/%d ", (int)GetCurrentProcessId(), cp,          \
-                __LINE__),                                                    \
-        fprintf x, fflush(stderr), 1)                                         \
-     : (1))
+#  define KWSYSPE_DEBUG(x)                                                    \
+    ((void*)cp == (void*)0x00226DE0                                           \
+       ? (fprintf(stderr, "%d/%p/%d ", (int)GetCurrentProcessId(), cp,        \
+                  __LINE__),                                                  \
+          fprintf x, fflush(stderr), 1)                                       \
+       : (1))
 #else
-#define KWSYSPE_DEBUG(x) (void)1
+#  define KWSYSPE_DEBUG(x) (void)1
 #endif
 
 typedef LARGE_INTEGER kwsysProcessTime;
@@ -355,16 +355,16 @@ kwsysProcess* kwsysProcess_New(void)
   ZeroMemory(&osv, sizeof(osv));
   osv.dwOSVersionInfoSize = sizeof(osv);
 #ifdef KWSYS_WINDOWS_DEPRECATED_GetVersionEx
-#pragma warning(push)
-#ifdef __INTEL_COMPILER
-#pragma warning(disable : 1478)
-#else
-#pragma warning(disable : 4996)
-#endif
+#  pragma warning(push)
+#  ifdef __INTEL_COMPILER
+#    pragma warning(disable : 1478)
+#  else
+#    pragma warning(disable : 4996)
+#  endif
 #endif
   GetVersionEx(&osv);
 #ifdef KWSYS_WINDOWS_DEPRECATED_GetVersionEx
-#pragma warning(pop)
+#  pragma warning(pop)
 #endif
   if (osv.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) {
     /* Win9x no longer supported.  */
@@ -2266,16 +2266,16 @@ static kwsysProcess_List* kwsysProcess_List_New(void)
   ZeroMemory(&osv, sizeof(osv));
   osv.dwOSVersionInfoSize = sizeof(osv);
 #ifdef KWSYS_WINDOWS_DEPRECATED_GetVersionEx
-#pragma warning(push)
-#ifdef __INTEL_COMPILER
-#pragma warning(disable : 1478)
-#else
-#pragma warning(disable : 4996)
-#endif
+#  pragma warning(push)
+#  ifdef __INTEL_COMPILER
+#    pragma warning(disable : 1478)
+#  else
+#    pragma warning(disable : 4996)
+#  endif
 #endif
   GetVersionEx(&osv);
 #ifdef KWSYS_WINDOWS_DEPRECATED_GetVersionEx
-#pragma warning(pop)
+#  pragma warning(pop)
 #endif
   self->NT4 =
     (osv.dwPlatformId == VER_PLATFORM_WIN32_NT && osv.dwMajorVersion < 5) ? 1
diff --git a/Source/kwsys/RegularExpression.cxx b/Source/kwsys/RegularExpression.cxx
index 78cff1a01..5f84b1946 100644
--- a/Source/kwsys/RegularExpression.cxx
+++ b/Source/kwsys/RegularExpression.cxx
@@ -25,7 +25,7 @@
 // Work-around CMake dependency scanning limitation.  This must
 // duplicate the above list of headers.
 #if 0
-#include "RegularExpression.hxx.in"
+#  include "RegularExpression.hxx.in"
 #endif
 
 #include <stdio.h>
@@ -194,24 +194,29 @@ bool RegularExpression::deep_equal(const RegularExpression& rxp) const
  */
 
 // definition   number  opnd?   meaning
-#define END 0     // no   End of program.
-#define BOL 1     // no   Match "" at beginning of line.
-#define EOL 2     // no   Match "" at end of line.
-#define ANY 3     // no   Match any one character.
-#define ANYOF 4   // str  Match any character in this string.
-#define ANYBUT 5  // str  Match any character not in this
-                  // string.
-#define BRANCH 6  // node Match this alternative, or the
+#define END 0   // no   End of program.
+#define BOL 1   // no   Match "" at beginning of line.
+#define EOL 2   // no   Match "" at end of line.
+#define ANY 3   // no   Match any one character.
+#define ANYOF 4 // str  Match any character in this string.
+#define ANYBUT                                                                \
+  5 // str  Match any character not in this
+    // string.
+#define BRANCH                                                                \
+  6               // node Match this alternative, or the
                   // next...
 #define BACK 7    // no   Match "", "next" ptr points backward.
 #define EXACTLY 8 // str  Match this string.
 #define NOTHING 9 // no   Match empty string.
-#define STAR 10   // node Match this (simple) thing 0 or more
-                  // times.
-#define PLUS 11   // node Match this (simple) thing 1 or more
-                  // times.
-#define OPEN 20   // no   Mark this point in input as start of
-                  // #n.
+#define STAR                                                                  \
+  10 // node Match this (simple) thing 0 or more
+     // times.
+#define PLUS                                                                  \
+  11 // node Match this (simple) thing 1 or more
+     // times.
+#define OPEN                                                                  \
+  20 // no   Mark this point in input as start of
+     // #n.
 // OPEN+1 is number 1, etc.
 #define CLOSE 30 // no   Analogous to OPEN.
 
diff --git a/Source/kwsys/RegularExpression.hxx.in b/Source/kwsys/RegularExpression.hxx.in
index 3cbbeb8b6..b7b93f962 100644
--- a/Source/kwsys/RegularExpression.hxx.in
+++ b/Source/kwsys/RegularExpression.hxx.in
@@ -29,7 +29,7 @@
 /* Disable useless Borland warnings.  KWSys tries not to force things
    on its includers, but there is no choice here.  */
 #if defined(__BORLANDC__)
-#pragma warn - 8027 /* function not inlined.  */
+#  pragma warn - 8027 /* function not inlined.  */
 #endif
 
 namespace @KWSYS_NAMESPACE@ {
@@ -138,8 +138,9 @@ inline std::string RegularExpressionMatch::match(int n) const
   if (this->startp[n] == 0) {
     return std::string();
   } else {
-    return std::string(this->startp[n], static_cast<std::string::size_type>(
-                                          this->endp[n] - this->startp[n]));
+    return std::string(
+      this->startp[n],
+      static_cast<std::string::size_type>(this->endp[n] - this->startp[n]));
   }
 }
 
@@ -218,7 +219,7 @@ inline std::string RegularExpressionMatch::match(int n) const
  * object as an argument and creates an object initialized with the
  * information from the given RegularExpression object.
  *
- * The  find  member function  finds   the  first  occurrence   of  the regular
+ * The  find  member function  finds   the  first  occurrence  of  the regular
  * expression of that object in the string given to find as an argument.  Find
  * returns a boolean, and  if true,  mutates  the private  data appropriately.
  * Find sets pointers to the beginning and end of  the thing last  found, they
@@ -230,9 +231,9 @@ inline std::string RegularExpressionMatch::match(int n) const
  * the  to see  if   the compiled  regular  expression   is the same, and  the
  * deep_equal functions also checks  to see if the  start and end pointers are
  * the same.  The is_valid  function returns false if  program is set to NULL,
- * (i.e. there is no valid compiled exression).  The set_invalid function sets
- * the  program to NULL  (Warning: this deletes the compiled  expression). The
- * following examples may help clarify regular expression usage:
+ * (i.e. there is no valid compiled  expression).  The  set_invalid   function
+ * sets the program to NULL (Warning:  this deletes the compiled  expression).
+ * The following examples may help clarify regular expression usage:
  *
  *   *  The regular expression  "^hello" matches  a "hello"  only at  the
  *      beginning of a  line.  It would match "hello  there" but not "hi,
@@ -270,13 +271,13 @@ inline std::string RegularExpressionMatch::match(int n) const
  *
  *   *  The regular expression "(..p)b" matches  something ending with pb
  *      and beginning with whatever the two characters before the first p
- *      encounterd in the line were.  It would find  "repb" in "rep drepa
+ *      encountered in the line were.  It would find "repb" in "rep drepa
  *      qrepb".  The regular expression "(..p)a"  would find "repa qrepb"
  *      in "rep drepa qrepb"
  *
  *   *  The regular expression "d(..p)" matches something ending  with p,
  *      beginning with d, and having  two characters  in between that are
- *      the same as the two characters before  the first p  encounterd in
+ *      the same as the two characters before  the first p encountered in
  *      the line.  It would match "drepa qrepb" in "rep drepa qrepb".
  *
  * All methods of RegularExpression can be called simultaneously from
diff --git a/Source/kwsys/SharedForward.h.in b/Source/kwsys/SharedForward.h.in
index 0caf5e7c3..5716cd4f1 100644
--- a/Source/kwsys/SharedForward.h.in
+++ b/Source/kwsys/SharedForward.h.in
@@ -1,7 +1,7 @@
 /* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
    file Copyright.txt or https://cmake.org/licensing#kwsys for details.  */
 #ifndef @KWSYS_NAMESPACE@_SharedForward_h
-#define @KWSYS_NAMESPACE@_SharedForward_h
+#  define @KWSYS_NAMESPACE@_SharedForward_h
 
 /*
   This header is used to create a forwarding executable sets up the
@@ -59,134 +59,134 @@
 
 /* Disable -Wcast-qual warnings since they are too hard to fix in a
    cross-platform way.  */
-#if defined(__clang__) && defined(__has_warning)
-#if __has_warning("-Wcast-qual")
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wcast-qual"
-#endif
-#endif
-
-#if defined(__BORLANDC__) && !defined(__cplusplus)
+#  if defined(__clang__) && defined(__has_warning)
+#    if __has_warning("-Wcast-qual")
+#      pragma clang diagnostic push
+#      pragma clang diagnostic ignored "-Wcast-qual"
+#    endif
+#  endif
+
+#  if defined(__BORLANDC__) && !defined(__cplusplus)
 /* Code has no effect; raised by winnt.h in C (not C++) when ignoring an
    unused parameter using "(param)" syntax (i.e. no cast to void).  */
-#pragma warn - 8019
-#endif
+#    pragma warn - 8019
+#  endif
 
 /* Full path to the directory in which this executable is built.  Do
    not include a trailing slash.  */
-#if !defined(@KWSYS_NAMESPACE@_SHARED_FORWARD_DIR_BUILD)
-#error "Must define @KWSYS_NAMESPACE@_SHARED_FORWARD_DIR_BUILD"
-#endif
-#if !defined(KWSYS_SHARED_FORWARD_DIR_BUILD)
-#define KWSYS_SHARED_FORWARD_DIR_BUILD                                        \
-  @KWSYS_NAMESPACE@_SHARED_FORWARD_DIR_BUILD
-#endif
+#  if !defined(@KWSYS_NAMESPACE@_SHARED_FORWARD_DIR_BUILD)
+#    error "Must define @KWSYS_NAMESPACE@_SHARED_FORWARD_DIR_BUILD"
+#  endif
+#  if !defined(KWSYS_SHARED_FORWARD_DIR_BUILD)
+#    define KWSYS_SHARED_FORWARD_DIR_BUILD                                    \
+      @KWSYS_NAMESPACE@_SHARED_FORWARD_DIR_BUILD
+#  endif
 
 /* Library search path for build tree.  */
-#if !defined(@KWSYS_NAMESPACE@_SHARED_FORWARD_PATH_BUILD)
-#error "Must define @KWSYS_NAMESPACE@_SHARED_FORWARD_PATH_BUILD"
-#endif
-#if !defined(KWSYS_SHARED_FORWARD_PATH_BUILD)
-#define KWSYS_SHARED_FORWARD_PATH_BUILD                                       \
-  @KWSYS_NAMESPACE@_SHARED_FORWARD_PATH_BUILD
-#endif
+#  if !defined(@KWSYS_NAMESPACE@_SHARED_FORWARD_PATH_BUILD)
+#    error "Must define @KWSYS_NAMESPACE@_SHARED_FORWARD_PATH_BUILD"
+#  endif
+#  if !defined(KWSYS_SHARED_FORWARD_PATH_BUILD)
+#    define KWSYS_SHARED_FORWARD_PATH_BUILD                                   \
+      @KWSYS_NAMESPACE@_SHARED_FORWARD_PATH_BUILD
+#  endif
 
 /* Library search path for install tree.  */
-#if !defined(@KWSYS_NAMESPACE@_SHARED_FORWARD_PATH_INSTALL)
-#error "Must define @KWSYS_NAMESPACE@_SHARED_FORWARD_PATH_INSTALL"
-#endif
-#if !defined(KWSYS_SHARED_FORWARD_PATH_INSTALL)
-#define KWSYS_SHARED_FORWARD_PATH_INSTALL                                     \
-  @KWSYS_NAMESPACE@_SHARED_FORWARD_PATH_INSTALL
-#endif
+#  if !defined(@KWSYS_NAMESPACE@_SHARED_FORWARD_PATH_INSTALL)
+#    error "Must define @KWSYS_NAMESPACE@_SHARED_FORWARD_PATH_INSTALL"
+#  endif
+#  if !defined(KWSYS_SHARED_FORWARD_PATH_INSTALL)
+#    define KWSYS_SHARED_FORWARD_PATH_INSTALL                                 \
+      @KWSYS_NAMESPACE@_SHARED_FORWARD_PATH_INSTALL
+#  endif
 
 /* The real executable to which to forward in the build tree.  */
-#if !defined(@KWSYS_NAMESPACE@_SHARED_FORWARD_EXE_BUILD)
-#error "Must define @KWSYS_NAMESPACE@_SHARED_FORWARD_EXE_BUILD"
-#endif
-#if !defined(KWSYS_SHARED_FORWARD_EXE_BUILD)
-#define KWSYS_SHARED_FORWARD_EXE_BUILD                                        \
-  @KWSYS_NAMESPACE@_SHARED_FORWARD_EXE_BUILD
-#endif
+#  if !defined(@KWSYS_NAMESPACE@_SHARED_FORWARD_EXE_BUILD)
+#    error "Must define @KWSYS_NAMESPACE@_SHARED_FORWARD_EXE_BUILD"
+#  endif
+#  if !defined(KWSYS_SHARED_FORWARD_EXE_BUILD)
+#    define KWSYS_SHARED_FORWARD_EXE_BUILD                                    \
+      @KWSYS_NAMESPACE@_SHARED_FORWARD_EXE_BUILD
+#  endif
 
 /* The real executable to which to forward in the install tree.  */
-#if !defined(@KWSYS_NAMESPACE@_SHARED_FORWARD_EXE_INSTALL)
-#error "Must define @KWSYS_NAMESPACE@_SHARED_FORWARD_EXE_INSTALL"
-#endif
-#if !defined(KWSYS_SHARED_FORWARD_EXE_INSTALL)
-#define KWSYS_SHARED_FORWARD_EXE_INSTALL                                      \
-  @KWSYS_NAMESPACE@_SHARED_FORWARD_EXE_INSTALL
-#endif
+#  if !defined(@KWSYS_NAMESPACE@_SHARED_FORWARD_EXE_INSTALL)
+#    error "Must define @KWSYS_NAMESPACE@_SHARED_FORWARD_EXE_INSTALL"
+#  endif
+#  if !defined(KWSYS_SHARED_FORWARD_EXE_INSTALL)
+#    define KWSYS_SHARED_FORWARD_EXE_INSTALL                                  \
+      @KWSYS_NAMESPACE@_SHARED_FORWARD_EXE_INSTALL
+#  endif
 
 /* The configuration name with which this executable was built (Debug/Release).
  */
-#if defined(@KWSYS_NAMESPACE@_SHARED_FORWARD_CONFIG_NAME)
-#define KWSYS_SHARED_FORWARD_CONFIG_NAME                                      \
-  @KWSYS_NAMESPACE@_SHARED_FORWARD_CONFIG_NAME
-#else
-#undef KWSYS_SHARED_FORWARD_CONFIG_NAME
-#endif
+#  if defined(@KWSYS_NAMESPACE@_SHARED_FORWARD_CONFIG_NAME)
+#    define KWSYS_SHARED_FORWARD_CONFIG_NAME                                  \
+      @KWSYS_NAMESPACE@_SHARED_FORWARD_CONFIG_NAME
+#  else
+#    undef KWSYS_SHARED_FORWARD_CONFIG_NAME
+#  endif
 
 /* Create command line option to replace executable.  */
-#if defined(@KWSYS_NAMESPACE@_SHARED_FORWARD_OPTION_COMMAND)
-#if !defined(KWSYS_SHARED_FORWARD_OPTION_COMMAND)
-#define KWSYS_SHARED_FORWARD_OPTION_COMMAND                                   \
-  @KWSYS_NAMESPACE@_SHARED_FORWARD_OPTION_COMMAND
-#endif
-#else
-#undef KWSYS_SHARED_FORWARD_OPTION_COMMAND
-#endif
+#  if defined(@KWSYS_NAMESPACE@_SHARED_FORWARD_OPTION_COMMAND)
+#    if !defined(KWSYS_SHARED_FORWARD_OPTION_COMMAND)
+#      define KWSYS_SHARED_FORWARD_OPTION_COMMAND                             \
+        @KWSYS_NAMESPACE@_SHARED_FORWARD_OPTION_COMMAND
+#    endif
+#  else
+#    undef KWSYS_SHARED_FORWARD_OPTION_COMMAND
+#  endif
 
 /* Create command line option to print environment setting and exit.  */
-#if defined(@KWSYS_NAMESPACE@_SHARED_FORWARD_OPTION_PRINT)
-#if !defined(KWSYS_SHARED_FORWARD_OPTION_PRINT)
-#define KWSYS_SHARED_FORWARD_OPTION_PRINT                                     \
-  @KWSYS_NAMESPACE@_SHARED_FORWARD_OPTION_PRINT
-#endif
-#else
-#undef KWSYS_SHARED_FORWARD_OPTION_PRINT
-#endif
+#  if defined(@KWSYS_NAMESPACE@_SHARED_FORWARD_OPTION_PRINT)
+#    if !defined(KWSYS_SHARED_FORWARD_OPTION_PRINT)
+#      define KWSYS_SHARED_FORWARD_OPTION_PRINT                               \
+        @KWSYS_NAMESPACE@_SHARED_FORWARD_OPTION_PRINT
+#    endif
+#  else
+#    undef KWSYS_SHARED_FORWARD_OPTION_PRINT
+#  endif
 
 /* Create command line option to run ldd or equivalent.  */
-#if defined(@KWSYS_NAMESPACE@_SHARED_FORWARD_OPTION_LDD)
-#if !defined(KWSYS_SHARED_FORWARD_OPTION_LDD)
-#define KWSYS_SHARED_FORWARD_OPTION_LDD                                       \
-  @KWSYS_NAMESPACE@_SHARED_FORWARD_OPTION_LDD
-#endif
-#else
-#undef KWSYS_SHARED_FORWARD_OPTION_LDD
-#endif
+#  if defined(@KWSYS_NAMESPACE@_SHARED_FORWARD_OPTION_LDD)
+#    if !defined(KWSYS_SHARED_FORWARD_OPTION_LDD)
+#      define KWSYS_SHARED_FORWARD_OPTION_LDD                                 \
+        @KWSYS_NAMESPACE@_SHARED_FORWARD_OPTION_LDD
+#    endif
+#  else
+#    undef KWSYS_SHARED_FORWARD_OPTION_LDD
+#  endif
 
 /* Include needed system headers.  */
 
-#include <errno.h>
-#include <limits.h>
-#include <stddef.h> /* size_t */
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
+#  include <errno.h>
+#  include <limits.h>
+#  include <stddef.h> /* size_t */
+#  include <stdio.h>
+#  include <stdlib.h>
+#  include <string.h>
 
-#if defined(_WIN32) && !defined(__CYGWIN__)
-#include <windows.h>
+#  if defined(_WIN32) && !defined(__CYGWIN__)
+#    include <windows.h>
 
-#include <io.h>
-#include <process.h>
-#define KWSYS_SHARED_FORWARD_ESCAPE_ARGV /* re-escape argv for execvp */
-#else
-#include <sys/stat.h>
-#include <unistd.h>
-#endif
+#    include <io.h>
+#    include <process.h>
+#    define KWSYS_SHARED_FORWARD_ESCAPE_ARGV /* re-escape argv for execvp */
+#  else
+#    include <sys/stat.h>
+#    include <unistd.h>
+#  endif
 
 /* Configuration for this platform.  */
 
 /* The path separator for this platform.  */
-#if defined(_WIN32) && !defined(__CYGWIN__)
-#define KWSYS_SHARED_FORWARD_PATH_SEP ';'
-#define KWSYS_SHARED_FORWARD_PATH_SLASH '\\'
-#else
-#define KWSYS_SHARED_FORWARD_PATH_SEP ':'
-#define KWSYS_SHARED_FORWARD_PATH_SLASH '/'
-#endif
+#  if defined(_WIN32) && !defined(__CYGWIN__)
+#    define KWSYS_SHARED_FORWARD_PATH_SEP ';'
+#    define KWSYS_SHARED_FORWARD_PATH_SLASH '\\'
+#  else
+#    define KWSYS_SHARED_FORWARD_PATH_SEP ':'
+#    define KWSYS_SHARED_FORWARD_PATH_SLASH '/'
+#  endif
 static const char kwsys_shared_forward_path_sep[2] = {
   KWSYS_SHARED_FORWARD_PATH_SEP, 0
 };
@@ -195,99 +195,101 @@ static const char kwsys_shared_forward_path_slash[2] = {
 };
 
 /* The maximum length of a file name.  */
-#if defined(PATH_MAX)
-#define KWSYS_SHARED_FORWARD_MAXPATH PATH_MAX
-#elif defined(MAXPATHLEN)
-#define KWSYS_SHARED_FORWARD_MAXPATH MAXPATHLEN
-#else
-#define KWSYS_SHARED_FORWARD_MAXPATH 16384
-#endif
+#  if defined(PATH_MAX)
+#    define KWSYS_SHARED_FORWARD_MAXPATH PATH_MAX
+#  elif defined(MAXPATHLEN)
+#    define KWSYS_SHARED_FORWARD_MAXPATH MAXPATHLEN
+#  else
+#    define KWSYS_SHARED_FORWARD_MAXPATH 16384
+#  endif
 
 /* Select the environment variable holding the shared library runtime
    search path for this platform and build configuration.  Also select
    ldd command equivalent.  */
 
 /* Linux */
-#if defined(__linux)
-#define KWSYS_SHARED_FORWARD_LDD "ldd"
-#define KWSYS_SHARED_FORWARD_LDD_N 1
-#define KWSYS_SHARED_FORWARD_LDPATH "LD_LIBRARY_PATH"
+#  if defined(__linux)
+#    define KWSYS_SHARED_FORWARD_LDD "ldd"
+#    define KWSYS_SHARED_FORWARD_LDD_N 1
+#    define KWSYS_SHARED_FORWARD_LDPATH "LD_LIBRARY_PATH"
 
 /* FreeBSD */
-#elif defined(__FreeBSD__)
-#define KWSYS_SHARED_FORWARD_LDD "ldd"
-#define KWSYS_SHARED_FORWARD_LDD_N 1
-#define KWSYS_SHARED_FORWARD_LDPATH "LD_LIBRARY_PATH"
+#  elif defined(__FreeBSD__)
+#    define KWSYS_SHARED_FORWARD_LDD "ldd"
+#    define KWSYS_SHARED_FORWARD_LDD_N 1
+#    define KWSYS_SHARED_FORWARD_LDPATH "LD_LIBRARY_PATH"
 
 /* OpenBSD */
-#elif defined(__OpenBSD__)
-#define KWSYS_SHARED_FORWARD_LDD "ldd"
-#define KWSYS_SHARED_FORWARD_LDD_N 1
-#define KWSYS_SHARED_FORWARD_LDPATH "LD_LIBRARY_PATH"
+#  elif defined(__OpenBSD__)
+#    define KWSYS_SHARED_FORWARD_LDD "ldd"
+#    define KWSYS_SHARED_FORWARD_LDD_N 1
+#    define KWSYS_SHARED_FORWARD_LDPATH "LD_LIBRARY_PATH"
 
 /* OS X */
-#elif defined(__APPLE__)
-#define KWSYS_SHARED_FORWARD_LDD "otool", "-L"
-#define KWSYS_SHARED_FORWARD_LDD_N 2
-#define KWSYS_SHARED_FORWARD_LDPATH "DYLD_LIBRARY_PATH"
+#  elif defined(__APPLE__)
+#    define KWSYS_SHARED_FORWARD_LDD "otool", "-L"
+#    define KWSYS_SHARED_FORWARD_LDD_N 2
+#    define KWSYS_SHARED_FORWARD_LDPATH "DYLD_LIBRARY_PATH"
 
 /* AIX */
-#elif defined(_AIX)
-#define KWSYS_SHARED_FORWARD_LDD "dump", "-H"
-#define KWSYS_SHARED_FORWARD_LDD_N 2
-#define KWSYS_SHARED_FORWARD_LDPATH "LIBPATH"
+#  elif defined(_AIX)
+#    define KWSYS_SHARED_FORWARD_LDD "dump", "-H"
+#    define KWSYS_SHARED_FORWARD_LDD_N 2
+#    define KWSYS_SHARED_FORWARD_LDPATH "LIBPATH"
 
 /* SUN */
-#elif defined(__sun)
-#define KWSYS_SHARED_FORWARD_LDD "ldd"
-#define KWSYS_SHARED_FORWARD_LDD_N 1
-#include <sys/isa_defs.h>
-#if defined(_ILP32)
-#define KWSYS_SHARED_FORWARD_LDPATH "LD_LIBRARY_PATH"
-#elif defined(_LP64)
-#define KWSYS_SHARED_FORWARD_LDPATH "LD_LIBRARY_PATH_64"
-#endif
+#  elif defined(__sun)
+#    define KWSYS_SHARED_FORWARD_LDD "ldd"
+#    define KWSYS_SHARED_FORWARD_LDD_N 1
+#    include <sys/isa_defs.h>
+#    if defined(_ILP32)
+#      define KWSYS_SHARED_FORWARD_LDPATH "LD_LIBRARY_PATH"
+#    elif defined(_LP64)
+#      define KWSYS_SHARED_FORWARD_LDPATH "LD_LIBRARY_PATH_64"
+#    endif
 
 /* HP-UX */
-#elif defined(__hpux)
-#define KWSYS_SHARED_FORWARD_LDD "chatr"
-#define KWSYS_SHARED_FORWARD_LDD_N 1
-#if defined(__LP64__)
-#define KWSYS_SHARED_FORWARD_LDPATH "LD_LIBRARY_PATH"
-#else
-#define KWSYS_SHARED_FORWARD_LDPATH "SHLIB_PATH"
-#endif
+#  elif defined(__hpux)
+#    define KWSYS_SHARED_FORWARD_LDD "chatr"
+#    define KWSYS_SHARED_FORWARD_LDD_N 1
+#    if defined(__LP64__)
+#      define KWSYS_SHARED_FORWARD_LDPATH "LD_LIBRARY_PATH"
+#    else
+#      define KWSYS_SHARED_FORWARD_LDPATH "SHLIB_PATH"
+#    endif
 
 /* SGI MIPS */
-#elif defined(__sgi) && defined(_MIPS_SIM)
-#define KWSYS_SHARED_FORWARD_LDD "ldd"
-#define KWSYS_SHARED_FORWARD_LDD_N 1
-#if _MIPS_SIM == _ABIO32
-#define KWSYS_SHARED_FORWARD_LDPATH "LD_LIBRARY_PATH"
-#elif _MIPS_SIM == _ABIN32
-#define KWSYS_SHARED_FORWARD_LDPATH "LD_LIBRARYN32_PATH"
-#elif _MIPS_SIM == _ABI64
-#define KWSYS_SHARED_FORWARD_LDPATH "LD_LIBRARY64_PATH"
-#endif
+#  elif defined(__sgi) && defined(_MIPS_SIM)
+#    define KWSYS_SHARED_FORWARD_LDD "ldd"
+#    define KWSYS_SHARED_FORWARD_LDD_N 1
+#    if _MIPS_SIM == _ABIO32
+#      define KWSYS_SHARED_FORWARD_LDPATH "LD_LIBRARY_PATH"
+#    elif _MIPS_SIM == _ABIN32
+#      define KWSYS_SHARED_FORWARD_LDPATH "LD_LIBRARYN32_PATH"
+#    elif _MIPS_SIM == _ABI64
+#      define KWSYS_SHARED_FORWARD_LDPATH "LD_LIBRARY64_PATH"
+#    endif
 
 /* Cygwin */
-#elif defined(__CYGWIN__)
-#define KWSYS_SHARED_FORWARD_LDD "cygcheck" /* TODO: cygwin 1.7 has ldd */
-#define KWSYS_SHARED_FORWARD_LDD_N 1
-#define KWSYS_SHARED_FORWARD_LDPATH "PATH"
+#  elif defined(__CYGWIN__)
+#    define KWSYS_SHARED_FORWARD_LDD                                          \
+      "cygcheck" /* TODO: cygwin 1.7 has ldd                                  \
+                  */
+#    define KWSYS_SHARED_FORWARD_LDD_N 1
+#    define KWSYS_SHARED_FORWARD_LDPATH "PATH"
 
 /* Windows */
-#elif defined(_WIN32)
-#define KWSYS_SHARED_FORWARD_LDPATH "PATH"
+#  elif defined(_WIN32)
+#    define KWSYS_SHARED_FORWARD_LDPATH "PATH"
 
 /* Guess on this unknown system.  */
-#else
-#define KWSYS_SHARED_FORWARD_LDD "ldd"
-#define KWSYS_SHARED_FORWARD_LDD_N 1
-#define KWSYS_SHARED_FORWARD_LDPATH "LD_LIBRARY_PATH"
-#endif
+#  else
+#    define KWSYS_SHARED_FORWARD_LDD "ldd"
+#    define KWSYS_SHARED_FORWARD_LDD_N 1
+#    define KWSYS_SHARED_FORWARD_LDPATH "LD_LIBRARY_PATH"
+#  endif
 
-#ifdef KWSYS_SHARED_FORWARD_ESCAPE_ARGV
+#  ifdef KWSYS_SHARED_FORWARD_ESCAPE_ARGV
 typedef struct kwsys_sf_arg_info_s
 {
   const char* arg;
@@ -404,25 +406,25 @@ static char* kwsys_sf_get_arg(kwsys_sf_arg_info info, char* out)
 
   return out;
 }
-#endif
+#  endif
 
 /* Function to convert a logical or relative path to a physical full path.  */
 static int kwsys_shared_forward_realpath(const char* in_path, char* out_path)
 {
-#if defined(_WIN32) && !defined(__CYGWIN__)
+#  if defined(_WIN32) && !defined(__CYGWIN__)
   /* Implementation for Windows.  */
   DWORD n =
     GetFullPathNameA(in_path, KWSYS_SHARED_FORWARD_MAXPATH, out_path, 0);
   return n > 0 && n <= KWSYS_SHARED_FORWARD_MAXPATH;
-#else
+#  else
   /* Implementation for UNIX.  */
   return realpath(in_path, out_path) != 0;
-#endif
+#  endif
 }
 
 static int kwsys_shared_forward_samepath(const char* file1, const char* file2)
 {
-#if defined(_WIN32)
+#  if defined(_WIN32)
   int result = 0;
   HANDLE h1 = CreateFileA(file1, GENERIC_READ, FILE_SHARE_READ, NULL,
                           OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
@@ -440,19 +442,19 @@ static int kwsys_shared_forward_samepath(const char* file1, const char* file2)
   CloseHandle(h1);
   CloseHandle(h2);
   return result;
-#else
+#  else
   struct stat fs1, fs2;
   return (stat(file1, &fs1) == 0 && stat(file2, &fs2) == 0 &&
           memcmp(&fs2.st_dev, &fs1.st_dev, sizeof(fs1.st_dev)) == 0 &&
           memcmp(&fs2.st_ino, &fs1.st_ino, sizeof(fs1.st_ino)) == 0 &&
           fs2.st_size == fs1.st_size);
-#endif
+#  endif
 }
 
 /* Function to report a system error message.  */
 static void kwsys_shared_forward_strerror(char* message)
 {
-#if defined(_WIN32) && !defined(__CYGWIN__)
+#  if defined(_WIN32) && !defined(__CYGWIN__)
   /* Implementation for Windows.  */
   DWORD original = GetLastError();
   DWORD length =
@@ -465,17 +467,17 @@ static void kwsys_shared_forward_strerror(char* message)
               "Error 0x%X (FormatMessage failed with error 0x%X)", original,
               GetLastError());
   }
-#else
+#  else
   /* Implementation for UNIX.  */
   strcpy(message, strerror(errno));
-#endif
+#  endif
 }
 
 /* Functions to execute a child process.  */
 static void kwsys_shared_forward_execvp(const char* cmd,
                                         char const* const* argv)
 {
-#ifdef KWSYS_SHARED_FORWARD_ESCAPE_ARGV
+#  ifdef KWSYS_SHARED_FORWARD_ESCAPE_ARGV
   /* Count the number of arguments.  */
   int argc = 0;
   {
@@ -498,16 +500,16 @@ static void kwsys_shared_forward_execvp(const char* cmd,
     /* Replace the command line to be used.  */
     argv = (char const* const*)nargv;
   }
-#endif
+#  endif
 
 /* Invoke the child process.  */
-#if defined(_MSC_VER)
+#  if defined(_MSC_VER)
   _execvp(cmd, argv);
-#elif defined(__MINGW32__) && !defined(__MINGW64__)
+#  elif defined(__MINGW32__) && !defined(__MINGW64__)
   execvp(cmd, argv);
-#else
+#  else
   execvp(cmd, (char* const*)argv);
-#endif
+#  endif
 }
 
 /* Function to get the directory containing the given file or directory.  */
@@ -530,14 +532,14 @@ static void kwsys_shared_forward_dirname(const char* begin, char* result)
     /* Only one leading slash.  */
     strcpy(result, kwsys_shared_forward_path_slash);
   }
-#if defined(_WIN32)
+#  if defined(_WIN32)
   else if (last_slash_index == 2 && begin[1] == ':') {
     /* Only one leading drive letter and slash.  */
     strncpy(result, begin, (size_t)last_slash_index);
     result[last_slash_index] = KWSYS_SHARED_FORWARD_PATH_SLASH;
     result[last_slash_index + 1] = 0;
   }
-#endif
+#  endif
   else {
     /* A non-leading slash.  */
     strncpy(result, begin, (size_t)last_slash_index);
@@ -548,16 +550,16 @@ static void kwsys_shared_forward_dirname(const char* begin, char* result)
 /* Function to check if a file exists and is executable.  */
 static int kwsys_shared_forward_is_executable(const char* f)
 {
-#if defined(_MSC_VER)
-#define KWSYS_SHARED_FORWARD_ACCESS _access
-#else
-#define KWSYS_SHARED_FORWARD_ACCESS access
-#endif
-#if defined(X_OK)
-#define KWSYS_SHARED_FORWARD_ACCESS_OK X_OK
-#else
-#define KWSYS_SHARED_FORWARD_ACCESS_OK 04
-#endif
+#  if defined(_MSC_VER)
+#    define KWSYS_SHARED_FORWARD_ACCESS _access
+#  else
+#    define KWSYS_SHARED_FORWARD_ACCESS access
+#  endif
+#  if defined(X_OK)
+#    define KWSYS_SHARED_FORWARD_ACCESS_OK X_OK
+#  else
+#    define KWSYS_SHARED_FORWARD_ACCESS_OK 04
+#  endif
   if (KWSYS_SHARED_FORWARD_ACCESS(f, KWSYS_SHARED_FORWARD_ACCESS_OK) == 0) {
     return 1;
   } else {
@@ -641,12 +643,12 @@ static int kwsys_shared_forward_fullpath(const char* self_path,
     /* Already a full path.  */
     strcpy(result, in_path);
   }
-#if defined(_WIN32)
+#  if defined(_WIN32)
   else if (in_path[0] && in_path[1] == ':') {
     /* Already a full path.  */
     strcpy(result, in_path);
   }
-#endif
+#  endif
   else {
     /* Relative to self path.  */
     char temp_path[KWSYS_SHARED_FORWARD_MAXPATH];
@@ -683,14 +685,14 @@ static int kwsys_shared_forward_get_settings(const char* self_path,
   const char* exe_path;
 
 /* Get the real name of the build and self paths.  */
-#if defined(KWSYS_SHARED_FORWARD_CONFIG_NAME)
+#  if defined(KWSYS_SHARED_FORWARD_CONFIG_NAME)
   char build_path[] =
     KWSYS_SHARED_FORWARD_DIR_BUILD "/" KWSYS_SHARED_FORWARD_CONFIG_NAME;
   char self_path_logical[KWSYS_SHARED_FORWARD_MAXPATH];
-#else
+#  else
   char build_path[] = KWSYS_SHARED_FORWARD_DIR_BUILD;
   const char* self_path_logical = self_path;
-#endif
+#  endif
   char build_path_real[KWSYS_SHARED_FORWARD_MAXPATH];
   char self_path_real[KWSYS_SHARED_FORWARD_MAXPATH];
   if (!kwsys_shared_forward_realpath(self_path, self_path_real)) {
@@ -706,29 +708,29 @@ static int kwsys_shared_forward_get_settings(const char* self_path,
       kwsys_shared_forward_samepath(self_path_real, build_path_real)) {
     /* Running in build tree.  Use the build path and exe.  */
     search_path = search_path_build;
-#if defined(_WIN32)
+#  if defined(_WIN32)
     exe_path = KWSYS_SHARED_FORWARD_EXE_BUILD ".exe";
-#else
+#  else
     exe_path = KWSYS_SHARED_FORWARD_EXE_BUILD;
-#endif
+#  endif
 
-#if defined(KWSYS_SHARED_FORWARD_CONFIG_NAME)
+#  if defined(KWSYS_SHARED_FORWARD_CONFIG_NAME)
     /* Remove the configuration directory from self_path.  */
     kwsys_shared_forward_dirname(self_path, self_path_logical);
-#endif
+#  endif
   } else {
     /* Running in install tree.  Use the install path and exe.  */
     search_path = search_path_install;
-#if defined(_WIN32)
+#  if defined(_WIN32)
     exe_path = KWSYS_SHARED_FORWARD_EXE_INSTALL ".exe";
-#else
+#  else
     exe_path = KWSYS_SHARED_FORWARD_EXE_INSTALL;
-#endif
+#  endif
 
-#if defined(KWSYS_SHARED_FORWARD_CONFIG_NAME)
+#  if defined(KWSYS_SHARED_FORWARD_CONFIG_NAME)
     /* Use the original self path directory.  */
     strcpy(self_path_logical, self_path);
-#endif
+#  endif
   }
 
   /* Construct the runtime search path.  */
@@ -795,7 +797,7 @@ static int @KWSYS_NAMESPACE@_shared_forward_to_real(int argc, char** argv_in)
       /* Store the environment variable.  */
       putenv(kwsys_shared_forward_ldpath);
 
-#if defined(KWSYS_SHARED_FORWARD_OPTION_COMMAND)
+#  if defined(KWSYS_SHARED_FORWARD_OPTION_COMMAND)
       /* Look for the command line replacement option.  */
       if (argc > 1 &&
           strcmp(argv[1], KWSYS_SHARED_FORWARD_OPTION_COMMAND) == 0) {
@@ -806,14 +808,15 @@ static int @KWSYS_NAMESPACE@_shared_forward_to_real(int argc, char** argv_in)
           argc -= 2;
         } else {
           /* The option was not given an executable.  */
-          fprintf(stderr, "Option " KWSYS_SHARED_FORWARD_OPTION_COMMAND
-                          " must be followed by a command line.\n");
+          fprintf(stderr,
+                  "Option " KWSYS_SHARED_FORWARD_OPTION_COMMAND
+                  " must be followed by a command line.\n");
           return 1;
         }
       }
-#endif
+#  endif
 
-#if defined(KWSYS_SHARED_FORWARD_OPTION_PRINT)
+#  if defined(KWSYS_SHARED_FORWARD_OPTION_PRINT)
       /* Look for the print command line option.  */
       if (argc > 1 &&
           strcmp(argv[1], KWSYS_SHARED_FORWARD_OPTION_PRINT) == 0) {
@@ -821,12 +824,12 @@ static int @KWSYS_NAMESPACE@_shared_forward_to_real(int argc, char** argv_in)
         fprintf(stdout, "%s\n", exe);
         return 0;
       }
-#endif
+#  endif
 
-#if defined(KWSYS_SHARED_FORWARD_OPTION_LDD)
+#  if defined(KWSYS_SHARED_FORWARD_OPTION_LDD)
       /* Look for the ldd command line option.  */
       if (argc > 1 && strcmp(argv[1], KWSYS_SHARED_FORWARD_OPTION_LDD) == 0) {
-#if defined(KWSYS_SHARED_FORWARD_LDD)
+#    if defined(KWSYS_SHARED_FORWARD_LDD)
         /* Use the named ldd-like executable and arguments.  */
         char const* ldd_argv[] = { KWSYS_SHARED_FORWARD_LDD, 0, 0 };
         ldd_argv[KWSYS_SHARED_FORWARD_LDD_N] = exe;
@@ -835,13 +838,13 @@ static int @KWSYS_NAMESPACE@_shared_forward_to_real(int argc, char** argv_in)
         /* Report why execution failed.  */
         kwsys_shared_forward_print_failure(ldd_argv);
         return 1;
-#else
+#    else
         /* We have no ldd-like executable available on this platform.  */
         fprintf(stderr, "No ldd-like tool is known to this executable.\n");
         return 1;
-#endif
+#    endif
       }
-#endif
+#  endif
 
       /* Replace this process with the real executable.  */
       argv[0] = exe;
@@ -865,12 +868,12 @@ static int @KWSYS_NAMESPACE@_shared_forward_to_real(int argc, char** argv_in)
 }
 
 /* Restore warning stack.  */
-#if defined(__clang__) && defined(__has_warning)
-#if __has_warning("-Wcast-qual")
-#pragma clang diagnostic pop
-#endif
-#endif
+#  if defined(__clang__) && defined(__has_warning)
+#    if __has_warning("-Wcast-qual")
+#      pragma clang diagnostic pop
+#    endif
+#  endif
 
 #else
-#error "@KWSYS_NAMESPACE@/SharedForward.h should be included only once."
+#  error "@KWSYS_NAMESPACE@/SharedForward.h should be included only once."
 #endif
diff --git a/Source/kwsys/String.c b/Source/kwsys/String.c
index 048222968..daf7ad1a0 100644
--- a/Source/kwsys/String.c
+++ b/Source/kwsys/String.c
@@ -8,23 +8,23 @@ directory that use the stl string cause the compiler to load this
 source to try to get the definition of the string template.  This
 condition blocks the compiler from seeing the symbols defined here.
 */
-#include "kwsysPrivate.h"
-#include KWSYS_HEADER(String.h)
+#  include "kwsysPrivate.h"
+#  include KWSYS_HEADER(String.h)
 
 /* Work-around CMake dependency scanning limitation.  This must
    duplicate the above list of headers.  */
-#if 0
-#include "String.h.in"
-#endif
+#  if 0
+#    include "String.h.in"
+#  endif
 
 /* Select an implementation for strcasecmp.  */
-#if defined(_MSC_VER)
-#define KWSYS_STRING_USE_STRICMP
-#include <string.h>
-#elif defined(__GNUC__)
-#define KWSYS_STRING_USE_STRCASECMP
-#include <strings.h>
-#else
+#  if defined(_MSC_VER)
+#    define KWSYS_STRING_USE_STRICMP
+#    include <string.h>
+#  elif defined(__GNUC__)
+#    define KWSYS_STRING_USE_STRCASECMP
+#    include <strings.h>
+#  else
 /* Table to convert upper case letters to lower case and leave all
    other characters alone.  */
 static char kwsysString_strcasecmp_tolower[] = {
@@ -58,16 +58,16 @@ static char kwsysString_strcasecmp_tolower[] = {
   '\363', '\364', '\365', '\366', '\367', '\370', '\371', '\372', '\373',
   '\374', '\375', '\376', '\377'
 };
-#endif
+#  endif
 
 /*--------------------------------------------------------------------------*/
 int kwsysString_strcasecmp(const char* lhs, const char* rhs)
 {
-#if defined(KWSYS_STRING_USE_STRICMP)
+#  if defined(KWSYS_STRING_USE_STRICMP)
   return _stricmp(lhs, rhs);
-#elif defined(KWSYS_STRING_USE_STRCASECMP)
+#  elif defined(KWSYS_STRING_USE_STRCASECMP)
   return strcasecmp(lhs, rhs);
-#else
+#  else
   const char* const lower = kwsysString_strcasecmp_tolower;
   unsigned char const* us1 = (unsigned char const*)lhs;
   unsigned char const* us2 = (unsigned char const*)rhs;
@@ -75,17 +75,17 @@ int kwsysString_strcasecmp(const char* lhs, const char* rhs)
   while ((result = lower[*us1] - lower[*us2++], result == 0) && *us1++) {
   }
   return result;
-#endif
+#  endif
 }
 
 /*--------------------------------------------------------------------------*/
 int kwsysString_strncasecmp(const char* lhs, const char* rhs, size_t n)
 {
-#if defined(KWSYS_STRING_USE_STRICMP)
+#  if defined(KWSYS_STRING_USE_STRICMP)
   return _strnicmp(lhs, rhs, n);
-#elif defined(KWSYS_STRING_USE_STRCASECMP)
+#  elif defined(KWSYS_STRING_USE_STRCASECMP)
   return strncasecmp(lhs, rhs, n);
-#else
+#  else
   const char* const lower = kwsysString_strcasecmp_tolower;
   unsigned char const* us1 = (unsigned char const*)lhs;
   unsigned char const* us2 = (unsigned char const*)rhs;
@@ -94,7 +94,7 @@ int kwsysString_strncasecmp(const char* lhs, const char* rhs, size_t n)
     --n;
   }
   return result;
-#endif
+#  endif
 }
 
 #endif /* KWSYS_STRING_C */
diff --git a/Source/kwsys/String.h.in b/Source/kwsys/String.h.in
index 3c1d571c0..7c9348af1 100644
--- a/Source/kwsys/String.h.in
+++ b/Source/kwsys/String.h.in
@@ -12,12 +12,12 @@
    not visible to user code.  Use kwsysHeaderDump.pl to reproduce
    these macros after making changes to the interface.  */
 #if !defined(KWSYS_NAMESPACE)
-#define kwsys_ns(x) @KWSYS_NAMESPACE@##x
-#define kwsysEXPORT @KWSYS_NAMESPACE@_EXPORT
+#  define kwsys_ns(x) @KWSYS_NAMESPACE@##x
+#  define kwsysEXPORT @KWSYS_NAMESPACE@_EXPORT
 #endif
 #if !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
-#define kwsysString_strcasecmp kwsys_ns(String_strcasecmp)
-#define kwsysString_strncasecmp kwsys_ns(String_strncasecmp)
+#  define kwsysString_strcasecmp kwsys_ns(String_strcasecmp)
+#  define kwsysString_strncasecmp kwsys_ns(String_strncasecmp)
 #endif
 
 #if defined(__cplusplus)
@@ -46,12 +46,12 @@ kwsysEXPORT int kwsysString_strncasecmp(const char* lhs, const char* rhs,
 /* If we are building a kwsys .c or .cxx file, let it use these macros.
    Otherwise, undefine them to keep the namespace clean.  */
 #if !defined(KWSYS_NAMESPACE)
-#undef kwsys_ns
-#undef kwsysEXPORT
-#if !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
-#undef kwsysString_strcasecmp
-#undef kwsysString_strncasecmp
-#endif
+#  undef kwsys_ns
+#  undef kwsysEXPORT
+#  if !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
+#    undef kwsysString_strcasecmp
+#    undef kwsysString_strncasecmp
+#  endif
 #endif
 
 #endif
diff --git a/Source/kwsys/System.c b/Source/kwsys/System.c
index b9af8e9d9..d43cc6fbb 100644
--- a/Source/kwsys/System.c
+++ b/Source/kwsys/System.c
@@ -6,7 +6,7 @@
 /* Work-around CMake dependency scanning limitation.  This must
    duplicate the above list of headers.  */
 #if 0
-#include "System.h.in"
+#  include "System.h.in"
 #endif
 
 #include <ctype.h>  /* isspace */
diff --git a/Source/kwsys/System.h.in b/Source/kwsys/System.h.in
index 102974db7..a9d4f5e69 100644
--- a/Source/kwsys/System.h.in
+++ b/Source/kwsys/System.h.in
@@ -10,11 +10,12 @@
    not visible to user code.  Use kwsysHeaderDump.pl to reproduce
    these macros after making changes to the interface.  */
 #if !defined(KWSYS_NAMESPACE)
-#define kwsys_ns(x) @KWSYS_NAMESPACE@##x
-#define kwsysEXPORT @KWSYS_NAMESPACE@_EXPORT
+#  define kwsys_ns(x) @KWSYS_NAMESPACE@##x
+#  define kwsysEXPORT @KWSYS_NAMESPACE@_EXPORT
 #endif
 #if !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
-#define kwsysSystem_Parse_CommandForUnix kwsys_ns(System_Parse_CommandForUnix)
+#  define kwsysSystem_Parse_CommandForUnix                                    \
+    kwsys_ns(System_Parse_CommandForUnix)
 #endif
 
 #if defined(__cplusplus)
@@ -49,11 +50,11 @@ kwsysEXPORT char** kwsysSystem_Parse_CommandForUnix(const char* command,
 /* If we are building a kwsys .c or .cxx file, let it use these macros.
    Otherwise, undefine them to keep the namespace clean.  */
 #if !defined(KWSYS_NAMESPACE)
-#undef kwsys_ns
-#undef kwsysEXPORT
-#if !defined(KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
-#undef kwsysSystem_Parse_CommandForUnix
-#endif
+#  undef kwsys_ns
+#  undef kwsysEXPORT
+#  if !defined(KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
+#    undef kwsysSystem_Parse_CommandForUnix
+#  endif
 #endif
 
 #endif
diff --git a/Source/kwsys/SystemInformation.cxx b/Source/kwsys/SystemInformation.cxx
index 2b9d7b174..cfe62b4b4 100644
--- a/Source/kwsys/SystemInformation.cxx
+++ b/Source/kwsys/SystemInformation.cxx
@@ -1,15 +1,15 @@
 /* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
    file Copyright.txt or https://cmake.org/licensing#kwsys for details.  */
 #if defined(_WIN32)
-#define NOMINMAX // use our min,max
-#if !defined(_WIN32_WINNT) && !(defined(_MSC_VER) && _MSC_VER < 1300)
-#define _WIN32_WINNT 0x0501
-#endif
-#include <winsock.h> // WSADATA, include before sys/types.h
+#  define NOMINMAX // use our min,max
+#  if !defined(_WIN32_WINNT) && !(defined(_MSC_VER) && _MSC_VER < 1300)
+#    define _WIN32_WINNT 0x0501
+#  endif
+#  include <winsock.h> // WSADATA, include before sys/types.h
 #endif
 
 #if (defined(__GNUC__) || defined(__PGI)) && !defined(_GNU_SOURCE)
-#define _GNU_SOURCE
+#  define _GNU_SOURCE
 #endif
 
 // TODO:
@@ -31,8 +31,8 @@
 // Work-around CMake dependency scanning limitation.  This must
 // duplicate the above list of headers.
 #if 0
-#include "Process.h.in"
-#include "SystemInformation.hxx.in"
+#  include "Process.h.in"
+#  include "SystemInformation.hxx.in"
 #endif
 
 #include <algorithm>
@@ -47,118 +47,116 @@
 #include <vector>
 
 #if defined(_WIN32)
-#include <windows.h>
-#if defined(_MSC_VER) && _MSC_VER >= 1800
-#define KWSYS_WINDOWS_DEPRECATED_GetVersionEx
-#endif
-#include <errno.h>
-#if defined(KWSYS_SYS_HAS_PSAPI)
-#include <psapi.h>
-#endif
-#if !defined(siginfo_t)
+#  include <windows.h>
+#  if defined(_MSC_VER) && _MSC_VER >= 1800
+#    define KWSYS_WINDOWS_DEPRECATED_GetVersionEx
+#  endif
+#  include <errno.h>
+#  if defined(KWSYS_SYS_HAS_PSAPI)
+#    include <psapi.h>
+#  endif
+#  if !defined(siginfo_t)
 typedef int siginfo_t;
-#endif
+#  endif
 #else
-#include <sys/types.h>
-
-#include <errno.h> // extern int errno;
-#include <fcntl.h>
-#include <signal.h>
-#include <sys/resource.h> // getrlimit
-#include <sys/time.h>
-#include <sys/utsname.h> // int uname(struct utsname *buf);
-#include <unistd.h>
+#  include <sys/types.h>
+
+#  include <errno.h> // extern int errno;
+#  include <fcntl.h>
+#  include <signal.h>
+#  include <sys/resource.h> // getrlimit
+#  include <sys/time.h>
+#  include <sys/utsname.h> // int uname(struct utsname *buf);
+#  include <unistd.h>
 #endif
 
 #if defined(__CYGWIN__) && !defined(_WIN32)
-#include <windows.h>
-#undef _WIN32
+#  include <windows.h>
+#  undef _WIN32
 #endif
 
 #if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__NetBSD__) ||    \
   defined(__DragonFly__)
-#include <netdb.h>
-#include <netinet/in.h>
-#include <sys/param.h>
-#include <sys/socket.h>
-#include <sys/sysctl.h>
-#if defined(KWSYS_SYS_HAS_IFADDRS_H)
-#include <ifaddrs.h>
-#include <net/if.h>
-#define KWSYS_SYSTEMINFORMATION_IMPLEMENT_FQDN
-#endif
+#  include <netdb.h>
+#  include <netinet/in.h>
+#  include <sys/param.h>
+#  include <sys/socket.h>
+#  include <sys/sysctl.h>
+#  if defined(KWSYS_SYS_HAS_IFADDRS_H)
+#    include <ifaddrs.h>
+#    include <net/if.h>
+#    define KWSYS_SYSTEMINFORMATION_IMPLEMENT_FQDN
+#  endif
 #endif
 
 #if defined(KWSYS_SYS_HAS_MACHINE_CPU_H)
-#include <machine/cpu.h>
+#  include <machine/cpu.h>
 #endif
 
 #ifdef __APPLE__
-#include <fenv.h>
-#include <mach/host_info.h>
-#include <mach/mach.h>
-#include <mach/mach_types.h>
-#include <mach/vm_statistics.h>
-#include <netdb.h>
-#include <netinet/in.h>
-#include <sys/socket.h>
-#include <sys/sysctl.h>
-#if defined(KWSYS_SYS_HAS_IFADDRS_H)
-#include <ifaddrs.h>
-#include <net/if.h>
-#define KWSYS_SYSTEMINFORMATION_IMPLEMENT_FQDN
-#endif
-#if !(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ - 0 >= 1050)
-#undef KWSYS_SYSTEMINFORMATION_HAS_BACKTRACE
-#endif
+#  include <mach/host_info.h>
+#  include <mach/mach.h>
+#  include <mach/mach_types.h>
+#  include <mach/vm_statistics.h>
+#  include <netdb.h>
+#  include <netinet/in.h>
+#  include <sys/socket.h>
+#  include <sys/sysctl.h>
+#  if defined(KWSYS_SYS_HAS_IFADDRS_H)
+#    include <ifaddrs.h>
+#    include <net/if.h>
+#    define KWSYS_SYSTEMINFORMATION_IMPLEMENT_FQDN
+#  endif
+#  if !(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ - 0 >= 1050)
+#    undef KWSYS_SYSTEMINFORMATION_HAS_BACKTRACE
+#  endif
 #endif
 
 #if defined(__linux) || defined(__sun) || defined(_SCO_DS)
-#include <fenv.h>
-#include <netdb.h>
-#include <netinet/in.h>
-#include <sys/socket.h>
-#if defined(KWSYS_SYS_HAS_IFADDRS_H)
-#include <ifaddrs.h>
-#include <net/if.h>
-#if defined(__LSB_VERSION__)
+#  include <netdb.h>
+#  include <netinet/in.h>
+#  include <sys/socket.h>
+#  if defined(KWSYS_SYS_HAS_IFADDRS_H)
+#    include <ifaddrs.h>
+#    include <net/if.h>
+#    if defined(__LSB_VERSION__)
 /* LSB has no getifaddrs */
-#elif defined(__ANDROID_API__) && __ANDROID_API__ < 24
+#    elif defined(__ANDROID_API__) && __ANDROID_API__ < 24
 /* Android has no getifaddrs prior to API 24.  */
-#else
-#define KWSYS_SYSTEMINFORMATION_IMPLEMENT_FQDN
-#endif
-#endif
-#if defined(KWSYS_CXX_HAS_RLIMIT64)
+#    else
+#      define KWSYS_SYSTEMINFORMATION_IMPLEMENT_FQDN
+#    endif
+#  endif
+#  if defined(KWSYS_CXX_HAS_RLIMIT64)
 typedef struct rlimit64 ResourceLimitType;
-#define GetResourceLimit getrlimit64
-#else
+#    define GetResourceLimit getrlimit64
+#  else
 typedef struct rlimit ResourceLimitType;
-#define GetResourceLimit getrlimit
-#endif
+#    define GetResourceLimit getrlimit
+#  endif
 #elif defined(__hpux)
-#include <sys/param.h>
-#include <sys/pstat.h>
-#if defined(KWSYS_SYS_HAS_MPCTL_H)
-#include <sys/mpctl.h>
-#endif
+#  include <sys/param.h>
+#  include <sys/pstat.h>
+#  if defined(KWSYS_SYS_HAS_MPCTL_H)
+#    include <sys/mpctl.h>
+#  endif
 #endif
 
 #ifdef __HAIKU__
-#include <OS.h>
+#  include <OS.h>
 #endif
 
 #if defined(KWSYS_SYSTEMINFORMATION_HAS_BACKTRACE)
-#include <execinfo.h>
-#if defined(KWSYS_SYSTEMINFORMATION_HAS_CPP_DEMANGLE)
-#include <cxxabi.h>
-#endif
-#if defined(KWSYS_SYSTEMINFORMATION_HAS_SYMBOL_LOOKUP)
-#include <dlfcn.h>
-#endif
+#  include <execinfo.h>
+#  if defined(KWSYS_SYSTEMINFORMATION_HAS_CPP_DEMANGLE)
+#    include <cxxabi.h>
+#  endif
+#  if defined(KWSYS_SYSTEMINFORMATION_HAS_SYMBOL_LOOKUP)
+#    include <dlfcn.h>
+#  endif
 #else
-#undef KWSYS_SYSTEMINFORMATION_HAS_CPP_DEMANGLE
-#undef KWSYS_SYSTEMINFORMATION_HAS_SYMBOL_LOOKUP
+#  undef KWSYS_SYSTEMINFORMATION_HAS_CPP_DEMANGLE
+#  undef KWSYS_SYSTEMINFORMATION_HAS_SYMBOL_LOOKUP
 #endif
 
 #include <ctype.h> // int isdigit(int c);
@@ -168,57 +166,57 @@ typedef struct rlimit ResourceLimitType;
 #include <string.h>
 
 #if defined(KWSYS_USE_LONG_LONG)
-#if defined(KWSYS_IOS_HAS_OSTREAM_LONG_LONG)
-#define iostreamLongLong(x) (x)
-#else
-#define iostreamLongLong(x) ((long)(x))
-#endif
+#  if defined(KWSYS_IOS_HAS_OSTREAM_LONG_LONG)
+#    define iostreamLongLong(x) (x)
+#  else
+#    define iostreamLongLong(x) ((long)(x))
+#  endif
 #elif defined(KWSYS_USE___INT64)
-#if defined(KWSYS_IOS_HAS_OSTREAM___INT64)
-#define iostreamLongLong(x) (x)
+#  if defined(KWSYS_IOS_HAS_OSTREAM___INT64)
+#    define iostreamLongLong(x) (x)
+#  else
+#    define iostreamLongLong(x) ((long)(x))
+#  endif
 #else
-#define iostreamLongLong(x) ((long)(x))
-#endif
-#else
-#error "No Long Long"
+#  error "No Long Long"
 #endif
 
 #if defined(KWSYS_CXX_HAS_ATOLL)
-#define atoLongLong atoll
-#else
-#if defined(KWSYS_CXX_HAS__ATOI64)
-#define atoLongLong _atoi64
-#elif defined(KWSYS_CXX_HAS_ATOL)
-#define atoLongLong atol
+#  define atoLongLong atoll
 #else
-#define atoLongLong atoi
-#endif
+#  if defined(KWSYS_CXX_HAS__ATOI64)
+#    define atoLongLong _atoi64
+#  elif defined(KWSYS_CXX_HAS_ATOL)
+#    define atoLongLong atol
+#  else
+#    define atoLongLong atoi
+#  endif
 #endif
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1300) && !defined(_WIN64) &&            \
   !defined(__clang__)
-#define USE_ASM_INSTRUCTIONS 1
+#  define USE_ASM_INSTRUCTIONS 1
 #else
-#define USE_ASM_INSTRUCTIONS 0
+#  define USE_ASM_INSTRUCTIONS 0
 #endif
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(__clang__)
-#include <intrin.h>
-#define USE_CPUID_INTRINSICS 1
+#  include <intrin.h>
+#  define USE_CPUID_INTRINSICS 1
 #else
-#define USE_CPUID_INTRINSICS 0
+#  define USE_CPUID_INTRINSICS 0
 #endif
 
 #if USE_ASM_INSTRUCTIONS || USE_CPUID_INTRINSICS ||                           \
   defined(KWSYS_CXX_HAS_BORLAND_ASM_CPUID)
-#define USE_CPUID 1
+#  define USE_CPUID 1
 #else
-#define USE_CPUID 0
+#  define USE_CPUID 0
 #endif
 
 #if USE_CPUID
 
-#define CPUID_AWARE_COMPILER
+#  define CPUID_AWARE_COMPILER
 
 /**
  * call CPUID instruction
@@ -227,16 +225,16 @@ typedef struct rlimit ResourceLimitType;
  */
 static bool call_cpuid(int select, int result[4])
 {
-#if USE_CPUID_INTRINSICS
+#  if USE_CPUID_INTRINSICS
   __cpuid(result, select);
   return true;
-#else
+#  else
   int tmp[4];
-#if defined(_MSC_VER)
+#    if defined(_MSC_VER)
   // Use SEH to determine CPUID presence
   __try {
     _asm {
-#ifdef CPUID_AWARE_COMPILER
+#      ifdef CPUID_AWARE_COMPILER
       ; we must push/pop the registers <<CPUID>> writes to, as the
       ; optimiser does not know about <<CPUID>>, and so does not expect
       ; these registers to change.
@@ -244,33 +242,33 @@ static bool call_cpuid(int select, int result[4])
       push ebx
       push ecx
       push edx
-#endif
+#      endif
       ; <<CPUID>>
       mov eax, select
-#ifdef CPUID_AWARE_COMPILER
+#      ifdef CPUID_AWARE_COMPILER
       cpuid
-#else
+#      else
       _asm _emit 0x0f
       _asm _emit 0xa2
-#endif
+#      endif
       mov tmp[0 * TYPE int], eax
       mov tmp[1 * TYPE int], ebx
       mov tmp[2 * TYPE int], ecx
       mov tmp[3 * TYPE int], edx
 
-#ifdef CPUID_AWARE_COMPILER
+#      ifdef CPUID_AWARE_COMPILER
       pop edx
       pop ecx
       pop ebx
       pop eax
-#endif
+#      endif
     }
   } __except (1) {
     return false;
   }
 
   memcpy(result, tmp, sizeof(tmp));
-#elif defined(KWSYS_CXX_HAS_BORLAND_ASM_CPUID)
+#    elif defined(KWSYS_CXX_HAS_BORLAND_ASM_CPUID)
   unsigned int a, b, c, d;
   __asm {
     mov EAX, select;
@@ -285,11 +283,11 @@ static bool call_cpuid(int select, int result[4])
   result[1] = b;
   result[2] = c;
   result[3] = d;
-#endif
+#    endif
 
   // The cpuid instruction succeeded.
   return true;
-#endif
+#  endif
 }
 #endif
 
@@ -906,7 +904,7 @@ int LoadLines(FILE* file, std::vector<std::string>& lines)
   return nRead;
 }
 
-#if defined(__linux)
+#  if defined(__linux)
 // *****************************************************************************
 int LoadLines(const char* fileName, std::vector<std::string>& lines)
 {
@@ -918,7 +916,7 @@ int LoadLines(const char* fileName, std::vector<std::string>& lines)
   fclose(file);
   return nRead;
 }
-#endif
+#  endif
 
 // ****************************************************************************
 template <typename T>
@@ -1007,7 +1005,7 @@ int GetFieldsFromCommand(const char* command, const char** fieldNames,
 void StacktraceSignalHandler(int sigNo, siginfo_t* sigInfo,
                              void* /*sigContext*/)
 {
-#if defined(__linux) || defined(__APPLE__)
+#  if defined(__linux) || defined(__APPLE__)
   std::ostringstream oss;
   oss << std::endl
       << "========================================================="
@@ -1031,17 +1029,17 @@ void StacktraceSignalHandler(int sigNo, siginfo_t* sigInfo,
           << (sigInfo->si_addr == KWSYS_NULLPTR ? "0x" : "")
           << sigInfo->si_addr << " ";
       switch (sigInfo->si_code) {
-#if defined(FPE_INTDIV)
+#    if defined(FPE_INTDIV)
         case FPE_INTDIV:
           oss << "integer division by zero";
           break;
-#endif
+#    endif
 
-#if defined(FPE_INTOVF)
+#    if defined(FPE_INTOVF)
         case FPE_INTOVF:
           oss << "integer overflow";
           break;
-#endif
+#    endif
 
         case FPE_FLTDIV:
           oss << "floating point divide by zero";
@@ -1063,11 +1061,11 @@ void StacktraceSignalHandler(int sigNo, siginfo_t* sigInfo,
           oss << "floating point invalid operation";
           break;
 
-#if defined(FPE_FLTSUB)
+#    if defined(FPE_FLTSUB)
         case FPE_FLTSUB:
           oss << "floating point subscript out of range";
           break;
-#endif
+#    endif
 
         default:
           oss << "code " << sigInfo->si_code;
@@ -1103,31 +1101,31 @@ void StacktraceSignalHandler(int sigNo, siginfo_t* sigInfo,
           oss << "invalid address alignment";
           break;
 
-#if defined(BUS_ADRERR)
+#    if defined(BUS_ADRERR)
         case BUS_ADRERR:
           oss << "nonexistent physical address";
           break;
-#endif
+#    endif
 
-#if defined(BUS_OBJERR)
+#    if defined(BUS_OBJERR)
         case BUS_OBJERR:
           oss << "object-specific hardware error";
           break;
-#endif
+#    endif
 
-#if defined(BUS_MCEERR_AR)
+#    if defined(BUS_MCEERR_AR)
         case BUS_MCEERR_AR:
           oss << "Hardware memory error consumed on a machine check; action "
                  "required.";
           break;
-#endif
+#    endif
 
-#if defined(BUS_MCEERR_AO)
+#    if defined(BUS_MCEERR_AO)
         case BUS_MCEERR_AO:
           oss << "Hardware memory error detected in process but not consumed; "
                  "action optional.";
           break;
-#endif
+#    endif
 
         default:
           oss << "code " << sigInfo->si_code;
@@ -1144,17 +1142,17 @@ void StacktraceSignalHandler(int sigNo, siginfo_t* sigInfo,
           oss << "illegal opcode";
           break;
 
-#if defined(ILL_ILLOPN)
+#    if defined(ILL_ILLOPN)
         case ILL_ILLOPN:
           oss << "illegal operand";
           break;
-#endif
+#    endif
 
-#if defined(ILL_ILLADR)
+#    if defined(ILL_ILLADR)
         case ILL_ILLADR:
           oss << "illegal addressing mode.";
           break;
-#endif
+#    endif
 
         case ILL_ILLTRP:
           oss << "illegal trap";
@@ -1164,23 +1162,23 @@ void StacktraceSignalHandler(int sigNo, siginfo_t* sigInfo,
           oss << "privileged opcode";
           break;
 
-#if defined(ILL_PRVREG)
+#    if defined(ILL_PRVREG)
         case ILL_PRVREG:
           oss << "privileged register";
           break;
-#endif
+#    endif
 
-#if defined(ILL_COPROC)
+#    if defined(ILL_COPROC)
         case ILL_COPROC:
           oss << "co-processor error";
           break;
-#endif
+#    endif
 
-#if defined(ILL_BADSTK)
+#    if defined(ILL_BADSTK)
         case ILL_BADSTK:
           oss << "internal stack error";
           break;
-#endif
+#    endif
 
         default:
           oss << "code " << sigInfo->si_code;
@@ -1203,16 +1201,16 @@ void StacktraceSignalHandler(int sigNo, siginfo_t* sigInfo,
   // and abort
   SystemInformationImplementation::SetStackTraceOnError(0);
   abort();
-#else
+#  else
   // avoid warning C4100
   (void)sigNo;
   (void)sigInfo;
-#endif
+#  endif
 }
 #endif
 
 #if defined(KWSYS_SYSTEMINFORMATION_HAS_BACKTRACE)
-#define safes(_arg) ((_arg) ? (_arg) : "???")
+#  define safes(_arg) ((_arg) ? (_arg) : "???")
 
 // Description:
 // A container for symbol properties. Each instance
@@ -1272,7 +1270,7 @@ public:
   long GetLineNumber() const { return this->LineNumber; }
 
   // Description:
-  // Set the address where the biinary image is mapped
+  // Set the address where the binary image is mapped
   // into memory.
   void SetBinaryBaseAddress(void* address)
   {
@@ -1300,19 +1298,19 @@ private:
 
 std::ostream& operator<<(std::ostream& os, const SymbolProperties& sp)
 {
-#if defined(KWSYS_SYSTEMINFORMATION_HAS_SYMBOL_LOOKUP)
+#  if defined(KWSYS_SYSTEMINFORMATION_HAS_SYMBOL_LOOKUP)
   os << std::hex << sp.GetAddress() << " : " << sp.GetFunction() << " [("
      << sp.GetBinary() << ") " << sp.GetSourceFile() << ":" << std::dec
      << sp.GetLineNumber() << "]";
-#elif defined(KWSYS_SYSTEMINFORMATION_HAS_BACKTRACE)
+#  elif defined(KWSYS_SYSTEMINFORMATION_HAS_BACKTRACE)
   void* addr = sp.GetAddress();
   char** syminfo = backtrace_symbols(&addr, 1);
   os << safes(syminfo[0]);
   free(syminfo);
-#else
+#  else
   (void)os;
   (void)sp;
-#endif
+#  endif
   return os;
 }
 
@@ -1349,7 +1347,7 @@ std::string SymbolProperties::GetFileName(const std::string& path) const
 std::string SymbolProperties::GetBinary() const
 {
 // only linux has proc fs
-#if defined(__linux__)
+#  if defined(__linux__)
   if (this->Binary == "/proc/self/exe") {
     std::string binary;
     char buf[1024] = { '\0' };
@@ -1362,14 +1360,14 @@ std::string SymbolProperties::GetBinary() const
     }
     return this->GetFileName(binary);
   }
-#endif
+#  endif
   return this->GetFileName(this->Binary);
 }
 
 std::string SymbolProperties::Demangle(const char* symbol) const
 {
   std::string result = safes(symbol);
-#if defined(KWSYS_SYSTEMINFORMATION_HAS_CPP_DEMANGLE)
+#  if defined(KWSYS_SYSTEMINFORMATION_HAS_CPP_DEMANGLE)
   int status = 0;
   size_t bufferLen = 1024;
   char* buffer = (char*)malloc(1024);
@@ -1379,16 +1377,16 @@ std::string SymbolProperties::Demangle(const char* symbol) const
     result = demangledSymbol;
   }
   free(buffer);
-#else
+#  else
   (void)symbol;
-#endif
+#  endif
   return result;
 }
 
 void SymbolProperties::Initialize(void* address)
 {
   this->Address = address;
-#if defined(KWSYS_SYSTEMINFORMATION_HAS_SYMBOL_LOOKUP)
+#  if defined(KWSYS_SYSTEMINFORMATION_HAS_SYMBOL_LOOKUP)
   // first fallback option can demangle c++ functions
   Dl_info info;
   int ierr = dladdr(this->Address, &info);
@@ -1396,18 +1394,18 @@ void SymbolProperties::Initialize(void* address)
     this->SetBinary(info.dli_fname);
     this->SetFunction(info.dli_sname);
   }
-#else
+#  else
 // second fallback use builtin backtrace_symbols
 // to decode the bactrace.
-#endif
+#  endif
 }
 #endif // don't define this class if we're not using it
 
 #if defined(_WIN32) || defined(__CYGWIN__)
-#define KWSYS_SYSTEMINFORMATION_USE_GetSystemTimes
+#  define KWSYS_SYSTEMINFORMATION_USE_GetSystemTimes
 #endif
 #if defined(_MSC_VER) && _MSC_VER < 1310
-#undef KWSYS_SYSTEMINFORMATION_USE_GetSystemTimes
+#  undef KWSYS_SYSTEMINFORMATION_USE_GetSystemTimes
 #endif
 #if defined(KWSYS_SYSTEMINFORMATION_USE_GetSystemTimes)
 double calculateCPULoad(unsigned __int64 idleTicks,
@@ -2012,12 +2010,12 @@ bool SystemInformationImplementation::DoesCPUSupportCPUID()
 #if USE_CPUID
   int dummy[4] = { 0, 0, 0, 0 };
 
-#if USE_ASM_INSTRUCTIONS
+#  if USE_ASM_INSTRUCTIONS
   return call_cpuid(0, dummy);
-#else
+#  else
   call_cpuid(0, dummy);
   return dummy[0] || dummy[1] || dummy[2] || dummy[3];
-#endif
+#  endif
 #else
   // Assume no cpuid instruction.
   return false;
@@ -2059,7 +2057,7 @@ bool SystemInformationImplementation::RetrieveCPUFeatures()
   this->Features.HasIA64 =
     ((cpuinfo[3] & 0x40000000) != 0); // IA64 Present --> Bit 30
 
-#if USE_ASM_INSTRUCTIONS
+#  if USE_ASM_INSTRUCTIONS
   // Retrieve extended SSE capabilities if SSE is available.
   if (this->Features.HasSSE) {
 
@@ -2083,9 +2081,9 @@ bool SystemInformationImplementation::RetrieveCPUFeatures()
     // Set the advanced SSE capabilities to not available.
     this->Features.HasSSEFP = false;
   }
-#else
+#  else
   this->Features.HasSSEFP = false;
-#endif
+#  endif
 
   // Retrieve Intel specific extended features.
   if (this->ChipManufacturer == Intel) {
@@ -3566,7 +3564,7 @@ bool SystemInformationImplementation::QueryProcessorBySysconf()
 {
 #if defined(_SC_NPROC_ONLN) && !defined(_SC_NPROCESSORS_ONLN)
 // IRIX names this slightly different
-#define _SC_NPROCESSORS_ONLN _SC_NPROC_ONLN
+#  define _SC_NPROCESSORS_ONLN _SC_NPROC_ONLN
 #endif
 
 #ifdef _SC_NPROCESSORS_ONLN
@@ -3596,17 +3594,17 @@ SystemInformation::LongLong
 SystemInformationImplementation::GetHostMemoryTotal()
 {
 #if defined(_WIN32)
-#if defined(_MSC_VER) && _MSC_VER < 1300
+#  if defined(_MSC_VER) && _MSC_VER < 1300
   MEMORYSTATUS stat;
   stat.dwLength = sizeof(stat);
   GlobalMemoryStatus(&stat);
   return stat.dwTotalPhys / 1024;
-#else
+#  else
   MEMORYSTATUSEX statex;
   statex.dwLength = sizeof(statex);
   GlobalMemoryStatusEx(&statex);
   return statex.ullTotalPhys / 1024;
-#endif
+#  endif
 #elif defined(__linux)
   SystemInformation::LongLong memTotal = 0;
   int ierr = GetFieldFromFile("/proc/meminfo", "MemTotal:", memTotal);
@@ -3721,17 +3719,17 @@ SystemInformation::LongLong
 SystemInformationImplementation::GetHostMemoryUsed()
 {
 #if defined(_WIN32)
-#if defined(_MSC_VER) && _MSC_VER < 1300
+#  if defined(_MSC_VER) && _MSC_VER < 1300
   MEMORYSTATUS stat;
   stat.dwLength = sizeof(stat);
   GlobalMemoryStatus(&stat);
   return (stat.dwTotalPhys - stat.dwAvailPhys) / 1024;
-#else
+#  else
   MEMORYSTATUSEX statex;
   statex.dwLength = sizeof(statex);
   GlobalMemoryStatusEx(&statex);
   return (statex.ullTotalPhys - statex.ullAvailPhys) / 1024;
-#endif
+#  endif
 #elif defined(__linux)
   // First try to use MemAvailable, but it only works on newer kernels
   const char* names2[3] = { "MemTotal:", "MemAvailable:", NULL };
@@ -3894,15 +3892,15 @@ std::string SystemInformationImplementation::GetProgramStack(int firstFrame,
                              "WARNING: The stack trace will not use advanced "
                              "capabilities because this is a release build.\n"
 #else
-#if !defined(KWSYS_SYSTEMINFORMATION_HAS_SYMBOL_LOOKUP)
+#  if !defined(KWSYS_SYSTEMINFORMATION_HAS_SYMBOL_LOOKUP)
                              "WARNING: Function names will not be demangled "
                              "because "
                              "dladdr is not available.\n"
-#endif
-#if !defined(KWSYS_SYSTEMINFORMATION_HAS_CPP_DEMANGLE)
+#  endif
+#  if !defined(KWSYS_SYSTEMINFORMATION_HAS_CPP_DEMANGLE)
                              "WARNING: Function names will not be demangled "
                              "because cxxabi is not available.\n"
-#endif
+#  endif
 #endif
     ;
 
@@ -3957,9 +3955,9 @@ void SystemInformationImplementation::SetStackTraceOnError(int enable)
     struct sigaction sa;
     sa.sa_sigaction = (SigAction)StacktraceSignalHandler;
     sa.sa_flags = SA_SIGINFO | SA_RESETHAND;
-#ifdef SA_RESTART
+#  ifdef SA_RESTART
     sa.sa_flags |= SA_RESTART;
-#endif
+#  endif
     sigemptyset(&sa.sa_mask);
 
     sigaction(SIGABRT, &sa, KWSYS_NULLPTR);
@@ -3991,21 +3989,21 @@ void SystemInformationImplementation::SetStackTraceOnError(int enable)
 bool SystemInformationImplementation::QueryWindowsMemory()
 {
 #if defined(_WIN32)
-#if defined(_MSC_VER) && _MSC_VER < 1300
+#  if defined(_MSC_VER) && _MSC_VER < 1300
   MEMORYSTATUS ms;
   unsigned long tv, tp, av, ap;
   ms.dwLength = sizeof(ms);
   GlobalMemoryStatus(&ms);
-#define MEM_VAL(value) dw##value
-#else
+#    define MEM_VAL(value) dw##value
+#  else
   MEMORYSTATUSEX ms;
   DWORDLONG tv, tp, av, ap;
   ms.dwLength = sizeof(ms);
   if (0 == GlobalMemoryStatusEx(&ms)) {
     return 0;
   }
-#define MEM_VAL(value) ull##value
-#endif
+#    define MEM_VAL(value) ull##value
+#  endif
   tv = ms.MEM_VAL(TotalPageFile);
   tp = ms.MEM_VAL(TotalPhys);
   av = ms.MEM_VAL(AvailPageFile);
@@ -4063,7 +4061,7 @@ bool SystemInformationImplementation::QueryLinuxMemory()
 
   if (linuxMajor >= 3 || ((linuxMajor >= 2) && (linuxMinor >= 6))) {
     // new /proc/meminfo format since kernel 2.6.x
-    // Rigorously, this test should check from the developping version 2.5.x
+    // Rigorously, this test should check from the developing version 2.5.x
     // that introduced the new format...
 
     enum
@@ -4188,7 +4186,7 @@ bool SystemInformationImplementation::QueryMemoryBySysconf()
   this->TotalPhysicalMemory = p;
   this->TotalPhysicalMemory /= pagediv;
 
-#if defined(_SC_AVPHYS_PAGES)
+#  if defined(_SC_AVPHYS_PAGES)
   p = sysconf(_SC_AVPHYS_PAGES);
   if (p < 0) {
     return false;
@@ -4196,7 +4194,7 @@ bool SystemInformationImplementation::QueryMemoryBySysconf()
 
   this->AvailablePhysicalMemory = p;
   this->AvailablePhysicalMemory /= pagediv;
-#endif
+#  endif
 
   return true;
 #else
@@ -4429,7 +4427,7 @@ bool SystemInformationImplementation::ParseSysCtl()
       static_cast<size_t>(available_memory / 1048576);
   }
 
-#ifdef VM_SWAPUSAGE
+#  ifdef VM_SWAPUSAGE
   // Virtual memory.
   int mib[2] = { CTL_VM, VM_SWAPUSAGE };
   size_t miblen = sizeof(mib) / sizeof(mib[0]);
@@ -4441,10 +4439,10 @@ bool SystemInformationImplementation::ParseSysCtl()
       static_cast<size_t>(swap.xsu_avail / 1048576);
     this->TotalVirtualMemory = static_cast<size_t>(swap.xsu_total / 1048576);
   }
-#else
+#  else
   this->AvailableVirtualMemory = 0;
   this->TotalVirtualMemory = 0;
-#endif
+#  endif
 
   // CPU Info
   len = sizeof(this->NumberOfPhysicalCPU);
@@ -4735,11 +4733,11 @@ bool SystemInformationImplementation::QuerySolarisMemory()
 // a 32 bit process on a 64 bit host the returned memory will be
 // limited to 4GiB. So if this is a 32 bit process or if the sysconf
 // method fails use the kstat interface.
-#if SIZEOF_VOID_P == 8
+#  if SIZEOF_VOID_P == 8
   if (this->QueryMemoryBySysconf()) {
     return true;
   }
-#endif
+#  endif
 
   char* tail;
   unsigned long totalMemory =
@@ -4902,12 +4900,12 @@ bool SystemInformationImplementation::QueryBSDMemory()
 #if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__NetBSD__) ||    \
   defined(__DragonFly__)
   int ctrl[2] = { CTL_HW, HW_PHYSMEM };
-#if defined(HW_PHYSMEM64)
+#  if defined(HW_PHYSMEM64)
   int64_t k;
   ctrl[1] = HW_PHYSMEM64;
-#else
+#  else
   int k;
-#endif
+#  endif
   size_t sz = sizeof(k);
 
   if (sysctl(ctrl, 2, &k, &sz, NULL, 0) != 0) {
@@ -4988,7 +4986,7 @@ bool SystemInformationImplementation::QueryBSDProcessor()
   this->NumberOfPhysicalCPU = k;
   this->NumberOfLogicalCPU = this->NumberOfPhysicalCPU;
 
-#if defined(HW_CPUSPEED)
+#  if defined(HW_CPUSPEED)
   ctrl[1] = HW_CPUSPEED;
 
   if (sysctl(ctrl, 2, &k, &sz, NULL, 0) != 0) {
@@ -4996,9 +4994,9 @@ bool SystemInformationImplementation::QueryBSDProcessor()
   }
 
   this->CPUSpeedInMHz = (float)k;
-#endif
+#  endif
 
-#if defined(CPU_SSE)
+#  if defined(CPU_SSE)
   ctrl[0] = CTL_MACHDEP;
   ctrl[1] = CPU_SSE;
 
@@ -5007,9 +5005,9 @@ bool SystemInformationImplementation::QueryBSDProcessor()
   }
 
   this->Features.HasSSE = (k > 0);
-#endif
+#  endif
 
-#if defined(CPU_SSE2)
+#  if defined(CPU_SSE2)
   ctrl[0] = CTL_MACHDEP;
   ctrl[1] = CPU_SSE2;
 
@@ -5018,9 +5016,9 @@ bool SystemInformationImplementation::QueryBSDProcessor()
   }
 
   this->Features.HasSSE2 = (k > 0);
-#endif
+#  endif
 
-#if defined(CPU_CPUVENDOR)
+#  if defined(CPU_CPUVENDOR)
   ctrl[0] = CTL_MACHDEP;
   ctrl[1] = CPU_CPUVENDOR;
   char vbuf[25];
@@ -5032,7 +5030,7 @@ bool SystemInformationImplementation::QueryBSDProcessor()
 
   this->ChipID.Vendor = vbuf;
   this->FindManufacturer();
-#endif
+#  endif
 
   return true;
 #else
@@ -5077,7 +5075,7 @@ bool SystemInformationImplementation::QueryHPUXMemory()
 bool SystemInformationImplementation::QueryHPUXProcessor()
 {
 #if defined(__hpux)
-#if defined(KWSYS_SYS_HAS_MPCTL_H)
+#  if defined(KWSYS_SYS_HAS_MPCTL_H)
   int c = mpctl(MPC_GETNUMSPUS_SYS, 0, 0);
   if (c <= 0) {
     return false;
@@ -5105,17 +5103,17 @@ bool SystemInformationImplementation::QueryHPUXProcessor()
       this->ChipID.Vendor = "Hewlett-Packard";
       this->ChipID.Family = 0x200;
       break;
-#if defined(CPU_HP_INTEL_EM_1_0) || defined(CPU_IA64_ARCHREV_0)
-#ifdef CPU_HP_INTEL_EM_1_0
+#    if defined(CPU_HP_INTEL_EM_1_0) || defined(CPU_IA64_ARCHREV_0)
+#      ifdef CPU_HP_INTEL_EM_1_0
     case CPU_HP_INTEL_EM_1_0:
-#endif
-#ifdef CPU_IA64_ARCHREV_0
+#      endif
+#      ifdef CPU_IA64_ARCHREV_0
     case CPU_IA64_ARCHREV_0:
-#endif
+#      endif
       this->ChipID.Vendor = "GenuineIntel";
       this->Features.HasIA64 = true;
       break;
-#endif
+#    endif
     default:
       return false;
   }
@@ -5123,9 +5121,9 @@ bool SystemInformationImplementation::QueryHPUXProcessor()
   this->FindManufacturer();
 
   return true;
-#else
+#  else
   return false;
-#endif
+#  endif
 #else
   return false;
 #endif
@@ -5146,14 +5144,14 @@ bool SystemInformationImplementation::QueryOSInformation()
   // Try calling GetVersionEx using the OSVERSIONINFOEX structure.
   ZeroMemory(&osvi, sizeof(OSVERSIONINFOEXW));
   osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXW);
-#ifdef KWSYS_WINDOWS_DEPRECATED_GetVersionEx
-#pragma warning(push)
-#ifdef __INTEL_COMPILER
-#pragma warning(disable : 1478)
-#else
-#pragma warning(disable : 4996)
-#endif
-#endif
+#  ifdef KWSYS_WINDOWS_DEPRECATED_GetVersionEx
+#    pragma warning(push)
+#    ifdef __INTEL_COMPILER
+#      pragma warning(disable : 1478)
+#    else
+#      pragma warning(disable : 4996)
+#    endif
+#  endif
   bOsVersionInfoEx = GetVersionExW((OSVERSIONINFOW*)&osvi);
   if (!bOsVersionInfoEx) {
     osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOW);
@@ -5161,9 +5159,9 @@ bool SystemInformationImplementation::QueryOSInformation()
       return false;
     }
   }
-#ifdef KWSYS_WINDOWS_DEPRECATED_GetVersionEx
-#pragma warning(pop)
-#endif
+#  ifdef KWSYS_WINDOWS_DEPRECATED_GetVersionEx
+#    pragma warning(pop)
+#  endif
 
   switch (osvi.dwPlatformId) {
     case VER_PLATFORM_WIN32_NT:
@@ -5181,7 +5179,7 @@ bool SystemInformationImplementation::QueryOSInformation()
       if (osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 2) {
         this->OSRelease = "XP";
       }
-#ifdef VER_NT_WORKSTATION
+#  ifdef VER_NT_WORKSTATION
       // Test for product type.
       if (bOsVersionInfoEx) {
         if (osvi.wProductType == VER_NT_WORKSTATION) {
@@ -5192,7 +5190,7 @@ bool SystemInformationImplementation::QueryOSInformation()
             this->OSRelease = "7";
           }
 // VER_SUITE_PERSONAL may not be defined
-#ifdef VER_SUITE_PERSONAL
+#    ifdef VER_SUITE_PERSONAL
           else {
             if (osvi.wSuiteMask & VER_SUITE_PERSONAL) {
               this->OSRelease += " Personal";
@@ -5200,7 +5198,7 @@ bool SystemInformationImplementation::QueryOSInformation()
               this->OSRelease += " Professional";
             }
           }
-#endif
+#    endif
         } else if (osvi.wProductType == VER_NT_SERVER) {
           // Check for .NET Server instead of Windows XP.
           if (osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 1) {
@@ -5221,7 +5219,7 @@ bool SystemInformationImplementation::QueryOSInformation()
                 osvi.dwBuildNumber & 0xFFFF);
         this->OSVersion = operatingSystem;
       } else
-#endif // VER_NT_WORKSTATION
+#  endif // VER_NT_WORKSTATION
       {
         HKEY hKey;
         wchar_t szProductType[80];
@@ -5372,7 +5370,7 @@ bool SystemInformationImplementation::QueryOSInformation()
     }
   }
 
-#ifdef __APPLE__
+#  ifdef __APPLE__
   this->OSName = "Unknown Apple OS";
   this->OSRelease = "Unknown product version";
   this->OSVersion = "Unknown build version";
@@ -5380,7 +5378,7 @@ bool SystemInformationImplementation::QueryOSInformation()
   this->CallSwVers("-productName", this->OSName);
   this->CallSwVers("-productVersion", this->OSRelease);
   this->CallSwVers("-buildVersion", this->OSVersion);
-#endif
+#  endif
 
 #endif
 
diff --git a/Source/kwsys/SystemInformation.hxx.in b/Source/kwsys/SystemInformation.hxx.in
index fe7e8b557..9e1ce6ce2 100644
--- a/Source/kwsys/SystemInformation.hxx.in
+++ b/Source/kwsys/SystemInformation.hxx.in
@@ -20,7 +20,7 @@ class @KWSYS_NAMESPACE@_EXPORT SystemInformation
 #elif @KWSYS_USE___INT64@
   typedef __int64 LongLong;
 #else
-#error "No Long Long"
+#  error "No Long Long"
 #endif
   friend class SystemInformationImplementation;
   SystemInformationImplementation* Implementation;
diff --git a/Source/kwsys/SystemTools.cxx b/Source/kwsys/SystemTools.cxx
index 106afe507..0079da286 100644
--- a/Source/kwsys/SystemTools.cxx
+++ b/Source/kwsys/SystemTools.cxx
@@ -1,18 +1,19 @@
 /* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
    file Copyright.txt or https://cmake.org/licensing#kwsys for details.  */
 #ifdef __osf__
-#define _OSF_SOURCE
-#define _POSIX_C_SOURCE 199506L
-#define _XOPEN_SOURCE_EXTENDED
+#  define _OSF_SOURCE
+#  define _POSIX_C_SOURCE 199506L
+#  define _XOPEN_SOURCE_EXTENDED
 #endif
 
-#if defined(_WIN32) && (defined(_MSC_VER) || defined(__WATCOMC__) ||          \
-                        defined(__BORLANDC__) || defined(__MINGW32__))
-#define KWSYS_WINDOWS_DIRS
+#if defined(_WIN32) &&                                                        \
+  (defined(_MSC_VER) || defined(__WATCOMC__) || defined(__BORLANDC__) ||      \
+   defined(__MINGW32__))
+#  define KWSYS_WINDOWS_DIRS
 #else
-#if defined(__SUNPRO_CC)
-#include <fcntl.h>
-#endif
+#  if defined(__SUNPRO_CC)
+#    include <fcntl.h>
+#  endif
 #endif
 
 #include "kwsysPrivate.h"
@@ -32,25 +33,25 @@
 // Work-around CMake dependency scanning limitation.  This must
 // duplicate the above list of headers.
 #if 0
-#include "Directory.hxx.in"
-#include "Encoding.hxx.in"
-#include "FStream.hxx.in"
-#include "RegularExpression.hxx.in"
-#include "SystemTools.hxx.in"
+#  include "Directory.hxx.in"
+#  include "Encoding.hxx.in"
+#  include "FStream.hxx.in"
+#  include "RegularExpression.hxx.in"
+#  include "SystemTools.hxx.in"
 #endif
 
 #ifdef _MSC_VER
-#pragma warning(disable : 4786)
+#  pragma warning(disable : 4786)
 #endif
 
 #if defined(__sgi) && !defined(__GNUC__)
-#pragma set woff 1375 /* base class destructor not virtual */
+#  pragma set woff 1375 /* base class destructor not virtual */
 #endif
 
 #include <ctype.h>
 #include <errno.h>
 #ifdef __QNX__
-#include <malloc.h> /* for malloc/free on QNX */
+#  include <malloc.h> /* for malloc/free on QNX */
 #endif
 #include <stdio.h>
 #include <stdlib.h>
@@ -58,42 +59,42 @@
 #include <time.h>
 
 #if defined(_WIN32) && !defined(_MSC_VER) && defined(__GNUC__)
-#include <strings.h> /* for strcasecmp */
+#  include <strings.h> /* for strcasecmp */
 #endif
 
 #ifdef _MSC_VER
-#define umask _umask // Note this is still umask on Borland
+#  define umask _umask // Note this is still umask on Borland
 #endif
 
 // support for realpath call
 #ifndef _WIN32
-#include <limits.h>
-#include <pwd.h>
-#include <sys/ioctl.h>
-#include <sys/time.h>
-#include <sys/wait.h>
-#include <unistd.h>
-#include <utime.h>
-#ifndef __VMS
-#include <sys/param.h>
-#include <termios.h>
-#endif
-#include <signal.h> /* sigprocmask */
+#  include <limits.h>
+#  include <pwd.h>
+#  include <sys/ioctl.h>
+#  include <sys/time.h>
+#  include <sys/wait.h>
+#  include <unistd.h>
+#  include <utime.h>
+#  ifndef __VMS
+#    include <sys/param.h>
+#    include <termios.h>
+#  endif
+#  include <signal.h> /* sigprocmask */
 #endif
 
 // Windows API.
 #if defined(_WIN32)
-#include <windows.h>
-#include <winioctl.h>
-#ifndef INVALID_FILE_ATTRIBUTES
-#define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
-#endif
-#if defined(_MSC_VER) && _MSC_VER >= 1800
-#define KWSYS_WINDOWS_DEPRECATED_GetVersionEx
-#endif
+#  include <windows.h>
+#  include <winioctl.h>
+#  ifndef INVALID_FILE_ATTRIBUTES
+#    define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
+#  endif
+#  if defined(_MSC_VER) && _MSC_VER >= 1800
+#    define KWSYS_WINDOWS_DEPRECATED_GetVersionEx
+#  endif
 #elif defined(__CYGWIN__)
-#include <windows.h>
-#undef _WIN32
+#  include <windows.h>
+#  undef _WIN32
 #endif
 
 #if !KWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H
@@ -101,18 +102,18 @@ extern char** environ;
 #endif
 
 #ifdef __CYGWIN__
-#include <sys/cygwin.h>
+#  include <sys/cygwin.h>
 #endif
 
 // getpwnam doesn't exist on Windows and Cray Xt3/Catamount
 // same for TIOCGWINSZ
 #if defined(_WIN32) || defined(__LIBCATAMOUNT__) ||                           \
   (defined(HAVE_GETPWNAM) && HAVE_GETPWNAM == 0)
-#undef HAVE_GETPWNAM
-#undef HAVE_TTY_INFO
+#  undef HAVE_GETPWNAM
+#  undef HAVE_TTY_INFO
 #else
-#define HAVE_GETPWNAM 1
-#define HAVE_TTY_INFO 1
+#  define HAVE_GETPWNAM 1
+#  define HAVE_TTY_INFO 1
 #endif
 
 #define VTK_URL_PROTOCOL_REGEX "([a-zA-Z0-9]*)://(.*)"
@@ -121,15 +122,15 @@ extern char** environ;
   "(.+)?"
 
 #ifdef _MSC_VER
-#include <sys/utime.h>
+#  include <sys/utime.h>
 #else
-#include <utime.h>
+#  include <utime.h>
 #endif
 
 // This is a hack to prevent warnings about these functions being
 // declared but not referenced.
 #if defined(__sgi) && !defined(__GNUC__)
-#include <sys/termios.h>
+#  include <sys/termios.h>
 namespace KWSYS_NAMESPACE {
 class SystemToolsHack
 {
@@ -147,32 +148,33 @@ public:
 }
 #endif
 
-#if defined(_WIN32) && (defined(_MSC_VER) || defined(__WATCOMC__) ||          \
-                        defined(__BORLANDC__) || defined(__MINGW32__))
-#include <direct.h>
-#include <io.h>
-#define _unlink unlink
+#if defined(_WIN32) &&                                                        \
+  (defined(_MSC_VER) || defined(__WATCOMC__) || defined(__BORLANDC__) ||      \
+   defined(__MINGW32__))
+#  include <direct.h>
+#  include <io.h>
+#  define _unlink unlink
 #endif
 
 /* The maximum length of a file name.  */
 #if defined(PATH_MAX)
-#define KWSYS_SYSTEMTOOLS_MAXPATH PATH_MAX
+#  define KWSYS_SYSTEMTOOLS_MAXPATH PATH_MAX
 #elif defined(MAXPATHLEN)
-#define KWSYS_SYSTEMTOOLS_MAXPATH MAXPATHLEN
+#  define KWSYS_SYSTEMTOOLS_MAXPATH MAXPATHLEN
 #else
-#define KWSYS_SYSTEMTOOLS_MAXPATH 16384
+#  define KWSYS_SYSTEMTOOLS_MAXPATH 16384
 #endif
 #if defined(__WATCOMC__)
-#include <direct.h>
-#define _mkdir mkdir
-#define _rmdir rmdir
-#define _getcwd getcwd
-#define _chdir chdir
+#  include <direct.h>
+#  define _mkdir mkdir
+#  define _rmdir rmdir
+#  define _getcwd getcwd
+#  define _chdir chdir
 #endif
 
 #if defined(__BEOS__) && !defined(__ZETA__)
-#include <be/kernel/OS.h>
-#include <be/storage/Path.h>
+#  include <be/kernel/OS.h>
+#  include <be/storage/Path.h>
 
 // BeOS 5 doesn't have usleep(), but it has snooze(), which is identical.
 static inline void usleep(unsigned int msec)
@@ -213,7 +215,7 @@ static time_t windows_filetime_to_posix_time(const FILETIME& ft)
 #endif
 
 #ifdef KWSYS_WINDOWS_DIRS
-#include <wctype.h>
+#  include <wctype.h>
 
 inline int Mkdir(const std::string& dir)
 {
@@ -245,11 +247,11 @@ inline const char* Getcwd(char* buf, unsigned int len)
 }
 inline int Chdir(const std::string& dir)
 {
-#if defined(__BORLANDC__)
+#  if defined(__BORLANDC__)
   return chdir(dir.c_str());
-#else
+#  else
   return _wchdir(KWSYS_NAMESPACE::Encoding::ToWide(dir).c_str());
-#endif
+#  endif
 }
 inline void Realpath(const std::string& path, std::string& resolved_path,
                      std::string* errorMessage = 0)
@@ -284,10 +286,10 @@ inline void Realpath(const std::string& path, std::string& resolved_path,
   }
 }
 #else
-#include <sys/types.h>
+#  include <sys/types.h>
 
-#include <fcntl.h>
-#include <unistd.h>
+#  include <fcntl.h>
+#  include <unistd.h>
 inline int Mkdir(const std::string& dir)
 {
   return mkdir(dir.c_str(), 00777);
@@ -429,13 +431,13 @@ struct SystemToolsPathCaseCmp
 {
   bool operator()(std::string const& l, std::string const& r) const
   {
-#ifdef _MSC_VER
+#  ifdef _MSC_VER
     return _stricmp(l.c_str(), r.c_str()) < 0;
-#elif defined(__GNUC__)
+#  elif defined(__GNUC__)
     return strcasecmp(l.c_str(), r.c_str()) < 0;
-#else
+#  else
     return SystemTools::Strucmp(l.c_str(), r.c_str()) < 0;
-#endif
+#  endif
   }
 };
 
@@ -672,9 +674,9 @@ bool SystemTools::UnPutEnv(const std::string& env)
    environment values that may still reference memory we allocated.  Then free
    the memory.  This will not affect any environment values we never set.  */
 
-#ifdef __INTEL_COMPILER
-#pragma warning disable 444 /* base has non-virtual destructor */
-#endif
+#  ifdef __INTEL_COMPILER
+#    pragma warning disable 444 /* base has non-virtual destructor */
+#  endif
 
 class kwsysEnv : public kwsysEnvSet
 {
@@ -682,39 +684,39 @@ public:
   ~kwsysEnv()
   {
     for (iterator i = this->begin(); i != this->end(); ++i) {
-#if defined(_WIN32)
+#  if defined(_WIN32)
       const std::string s = Encoding::ToNarrow(*i);
       kwsysUnPutEnv(s.c_str());
-#else
+#  else
       kwsysUnPutEnv(*i);
-#endif
+#  endif
       free(const_cast<envchar*>(*i));
     }
   }
   bool Put(const char* env)
   {
-#if defined(_WIN32)
+#  if defined(_WIN32)
     const std::wstring wEnv = Encoding::ToWide(env);
     wchar_t* newEnv = _wcsdup(wEnv.c_str());
-#else
+#  else
     char* newEnv = strdup(env);
-#endif
+#  endif
     Free oldEnv(this->Release(newEnv));
     this->insert(newEnv);
-#if defined(_WIN32)
+#  if defined(_WIN32)
     return _wputenv(newEnv) == 0;
-#else
+#  else
     return putenv(newEnv) == 0;
-#endif
+#  endif
   }
   bool UnPut(const char* env)
   {
-#if defined(_WIN32)
+#  if defined(_WIN32)
     const std::wstring wEnv = Encoding::ToWide(env);
     Free oldEnv(this->Release(wEnv.c_str()));
-#else
+#  else
     Free oldEnv(this->Release(env));
-#endif
+#  endif
     return kwsysUnPutEnv(env) == 0;
   }
 };
@@ -792,7 +794,7 @@ bool SystemTools::MakeDirectory(const std::string& path, const mode_t* mode)
 #ifdef __BORLANDC__
         && (errno != EACCES)
 #endif
-          ) {
+    ) {
       return false;
     }
   } else if (mode != KWSYS_NULLPTR) {
@@ -862,13 +864,13 @@ void SystemTools::ReplaceString(std::string& source, const char* replace,
 
 #if defined(_WIN32) && !defined(__CYGWIN__)
 
-#if defined(KEY_WOW64_32KEY) && defined(KEY_WOW64_64KEY)
-#define KWSYS_ST_KEY_WOW64_32KEY KEY_WOW64_32KEY
-#define KWSYS_ST_KEY_WOW64_64KEY KEY_WOW64_64KEY
-#else
-#define KWSYS_ST_KEY_WOW64_32KEY 0x0200
-#define KWSYS_ST_KEY_WOW64_64KEY 0x0100
-#endif
+#  if defined(KEY_WOW64_32KEY) && defined(KEY_WOW64_64KEY)
+#    define KWSYS_ST_KEY_WOW64_32KEY KEY_WOW64_32KEY
+#    define KWSYS_ST_KEY_WOW64_64KEY KEY_WOW64_64KEY
+#  else
+#    define KWSYS_ST_KEY_WOW64_32KEY 0x0200
+#    define KWSYS_ST_KEY_WOW64_64KEY 0x0100
+#  endif
 
 static bool SystemToolsParseRegistryKey(const std::string& key,
                                         HKEY& primaryKey, std::string& second,
@@ -1200,11 +1202,11 @@ bool SystemTools::FileExists(const std::string& filename)
     INVALID_FILE_ATTRIBUTES);
 #else
 // SCO OpenServer 5.0.7/3.2's command has 711 permission.
-#if defined(_SCO_DS)
+#  if defined(_SCO_DS)
   return access(filename.c_str(), F_OK) == 0;
-#else
+#  else
   return access(filename.c_str(), R_OK) == 0;
-#endif
+#  endif
 #endif
 }
 
@@ -1276,11 +1278,11 @@ int SystemTools::Stat(const std::string& path, SystemTools::Stat_t* buf)
   // long paths, but _wstat64 rejects paths with '?' in them, thinking
   // they are wildcards.
   std::wstring const& wpath = Encoding::ToWide(path);
-#if defined(__BORLANDC__)
+#  if defined(__BORLANDC__)
   return _wstati64(wpath.c_str(), buf);
-#else
+#  else
   return _wstat64(wpath.c_str(), buf);
-#endif
+#  endif
 #else
   return stat(path.c_str(), buf);
 #endif
@@ -1346,28 +1348,28 @@ bool SystemTools::Touch(const std::string& filename, bool create)
   }
   struct timeval mtime;
   gettimeofday(&mtime, 0);
-#if KWSYS_CXX_HAS_UTIMES
+#  if KWSYS_CXX_HAS_UTIMES
   struct timeval atime;
-#if KWSYS_CXX_STAT_HAS_ST_MTIM
+#    if KWSYS_CXX_STAT_HAS_ST_MTIM
   atime.tv_sec = st.st_atim.tv_sec;
   atime.tv_usec = st.st_atim.tv_nsec / 1000;
-#elif KWSYS_CXX_STAT_HAS_ST_MTIMESPEC
+#    elif KWSYS_CXX_STAT_HAS_ST_MTIMESPEC
   atime.tv_sec = st.st_atimespec.tv_sec;
   atime.tv_usec = st.st_atimespec.tv_nsec / 1000;
-#else
+#    else
   atime.tv_sec = st.st_atime;
   atime.tv_usec = 0;
-#endif
+#    endif
   struct timeval times[2] = { atime, mtime };
   if (utimes(filename.c_str(), times) < 0) {
     return false;
   }
-#else
+#  else
   struct utimbuf times = { st.st_atime, mtime.tv_sec };
   if (utime(filename.c_str(), &times) < 0) {
     return false;
   }
-#endif
+#  endif
 #endif
   return true;
 }
@@ -1387,7 +1389,7 @@ bool SystemTools::FileTimeCompare(const std::string& f1, const std::string& f2,
   if (stat(f2.c_str(), &s2) != 0) {
     return false;
   }
-#if KWSYS_CXX_STAT_HAS_ST_MTIM
+#  if KWSYS_CXX_STAT_HAS_ST_MTIM
   // Compare using nanosecond resolution.
   if (s1.st_mtim.tv_sec < s2.st_mtim.tv_sec) {
     *result = -1;
@@ -1398,7 +1400,7 @@ bool SystemTools::FileTimeCompare(const std::string& f1, const std::string& f2,
   } else if (s1.st_mtim.tv_nsec > s2.st_mtim.tv_nsec) {
     *result = 1;
   }
-#elif KWSYS_CXX_STAT_HAS_ST_MTIMESPEC
+#  elif KWSYS_CXX_STAT_HAS_ST_MTIMESPEC
   // Compare using nanosecond resolution.
   if (s1.st_mtimespec.tv_sec < s2.st_mtimespec.tv_sec) {
     *result = -1;
@@ -1409,14 +1411,14 @@ bool SystemTools::FileTimeCompare(const std::string& f1, const std::string& f2,
   } else if (s1.st_mtimespec.tv_nsec > s2.st_mtimespec.tv_nsec) {
     *result = 1;
   }
-#else
+#  else
   // Compare using 1 second resolution.
   if (s1.st_mtime < s2.st_mtime) {
     *result = -1;
   } else if (s1.st_mtime > s2.st_mtime) {
     *result = 1;
   }
-#endif
+#  endif
 #else
   // Windows version.  Get the modification time from extended file attributes.
   WIN32_FILE_ATTRIBUTE_DATA f1d;
@@ -1900,15 +1902,15 @@ void SystemTools::ConvertToUnixSlashes(std::string& path)
 
     // Also, reuse the loop to check for slash followed by another slash
     if (!hasDoubleSlash && *(pos0 + 1) == '/' && *(pos0 + 2) == '/') {
-#ifdef _WIN32
+#  ifdef _WIN32
       // However, on windows if the first characters are both slashes,
       // then keep them that way, so that network paths can be handled.
       if (pos > 0) {
         hasDoubleSlash = true;
       }
-#else
+#  else
       hasDoubleSlash = true;
-#endif
+#  endif
     }
 
     pos0++;
@@ -2282,7 +2284,9 @@ bool SystemTools::CopyADirectory(const std::string& source,
                                  const std::string& destination, bool always)
 {
   Directory dir;
-  dir.Load(source);
+  if (dir.Load(source) == 0) {
+    return false;
+  }
   size_t fileNum;
   if (!SystemTools::MakeDirectory(destination)) {
     return false;
@@ -2394,7 +2398,7 @@ std::string SystemTools::GetLastSystemError()
 
 static bool IsJunction(const std::wstring& source)
 {
-#ifdef FSCTL_GET_REPARSE_POINT
+#  ifdef FSCTL_GET_REPARSE_POINT
   const DWORD JUNCTION_ATTRS =
     FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_REPARSE_POINT;
   DWORD attrs = GetFileAttributesW(source.c_str());
@@ -2436,14 +2440,14 @@ static bool IsJunction(const std::wstring& source)
 
   return (success &&
           (reparse_buffer->ReparseTag == IO_REPARSE_TAG_MOUNT_POINT));
-#else
+#  else
   return false;
-#endif
+#  endif
 }
 
 static bool DeleteJunction(const std::wstring& source)
 {
-#ifdef FSCTL_DELETE_REPARSE_POINT
+#  ifdef FSCTL_DELETE_REPARSE_POINT
   // Adjust privileges so that we can succefully open junction points as
   // read/write.
   HANDLE token;
@@ -2478,9 +2482,9 @@ static bool DeleteJunction(const std::wstring& source)
   CloseHandle(dir);
 
   return !!success;
-#else
+#  else
   return false;
-#endif
+#  endif
 }
 
 #endif
@@ -3293,7 +3297,7 @@ std::string SystemTools::RelativePath(const std::string& local,
 #else
          localSplit[sameCount] == remoteSplit[sameCount]
 #endif
-         ) {
+  ) {
     // put the common parts of the path into the commonPath array
     commonPath.push_back(localSplit[sameCount]);
     // erase the common parts of the path from the original path arrays
@@ -3344,15 +3348,20 @@ std::string SystemTools::RelativePath(const std::string& local,
 static std::string GetCasePathName(std::string const& pathIn)
 {
   std::string casePath;
-  std::vector<std::string> path_components;
-  SystemTools::SplitPath(pathIn, path_components);
-  if (path_components[0].empty()) // First component always exists.
-  {
-    // Relative paths cannot be converted.
+
+  // First check if the file is relative. We don't fix relative paths since the
+  // real case depends on the root directory and the given path fragment may
+  // have meaning elsewhere in the project.
+  if (!SystemTools::FileIsFullPath(pathIn)) {
+    // This looks unnecessary, but it allows for the return value optimization
+    // since all return paths return the same local variable.
     casePath = pathIn;
     return casePath;
   }
 
+  std::vector<std::string> path_components;
+  SystemTools::SplitPath(pathIn, path_components);
+
   // Start with root component.
   std::vector<std::string>::size_type idx = 0;
   casePath = path_components[idx++];
@@ -3594,13 +3603,13 @@ std::string SystemTools::JoinPath(
 bool SystemTools::ComparePath(const std::string& c1, const std::string& c2)
 {
 #if defined(_WIN32) || defined(__APPLE__)
-#ifdef _MSC_VER
+#  ifdef _MSC_VER
   return _stricmp(c1.c_str(), c2.c_str()) == 0;
-#elif defined(__APPLE__) || defined(__GNUC__)
+#  elif defined(__APPLE__) || defined(__GNUC__)
   return strcasecmp(c1.c_str(), c2.c_str()) == 0;
-#else
+#  else
   return SystemTools::Strucmp(c1.c_str(), c2.c_str()) == 0;
-#endif
+#  endif
 #else
   return c1 == c2;
 #endif
@@ -4025,23 +4034,16 @@ std::string SystemTools::MakeCidentifier(const std::string& s)
   return str;
 }
 
-// Due to a buggy stream library on the HP and another on Mac OS X, we
-// need this very carefully written version of getline.  Returns true
+// Convenience function around std::getline which removes a trailing carriage
+// return and can truncate the buffer as needed.  Returns true
 // if any data were read before the end-of-file was reached.
 bool SystemTools::GetLineFromStream(std::istream& is, std::string& line,
                                     bool* has_newline /* = 0 */,
                                     long sizeLimit /* = -1 */)
 {
-  const int bufferSize = 1024;
-  char buffer[bufferSize];
-  bool haveData = false;
-  bool haveNewline = false;
-
   // Start with an empty line.
   line = "";
 
-  long leftToRead = sizeLimit;
-
   // Early short circuit return if stream is no good. Just return
   // false and the empty line. (Probably means caller tried to
   // create a file stream with a non-existent file name...)
@@ -4053,44 +4055,23 @@ bool SystemTools::GetLineFromStream(std::istream& is, std::string& line,
     return false;
   }
 
-  // If no characters are read from the stream, the end of file has
-  // been reached.  Clear the fail bit just before reading.
-  while (!haveNewline && leftToRead != 0 &&
-         (static_cast<void>(is.clear(is.rdstate() & ~std::ios::failbit)),
-          static_cast<void>(is.getline(buffer, bufferSize)),
-          is.gcount() > 0)) {
-    // We have read at least one byte.
-    haveData = true;
-
-    // If newline character was read the gcount includes the character
-    // but the buffer does not: the end of line has been reached.
-    size_t length = strlen(buffer);
-    if (length < static_cast<size_t>(is.gcount())) {
-      haveNewline = true;
-    }
-
+  std::getline(is, line);
+  bool haveData = !line.empty() || !is.eof();
+  if (!line.empty()) {
     // Avoid storing a carriage return character.
-    if (length > 0 && buffer[length - 1] == '\r') {
-      buffer[length - 1] = 0;
+    if (*line.rbegin() == '\r') {
+      line.resize(line.size() - 1);
     }
 
     // if we read too much then truncate the buffer
-    if (leftToRead > 0) {
-      if (static_cast<long>(length) > leftToRead) {
-        buffer[leftToRead] = 0;
-        leftToRead = 0;
-      } else {
-        leftToRead -= static_cast<long>(length);
-      }
+    if (sizeLimit >= 0 && line.size() >= static_cast<size_t>(sizeLimit)) {
+      line.resize(sizeLimit);
     }
-
-    // Append the data read to the line.
-    line.append(buffer);
   }
 
   // Return the results.
   if (has_newline) {
-    *has_newline = haveNewline;
+    *has_newline = !is.eof();
   }
   return haveData;
 }
@@ -4151,8 +4132,9 @@ bool SystemTools::GetPermissions(const std::string& file, mode_t& mode)
   }
   size_t dotPos = file.rfind('.');
   const char* ext = dotPos == std::string::npos ? 0 : (file.c_str() + dotPos);
-  if (ext && (Strucmp(ext, ".exe") == 0 || Strucmp(ext, ".com") == 0 ||
-              Strucmp(ext, ".cmd") == 0 || Strucmp(ext, ".bat") == 0)) {
+  if (ext &&
+      (Strucmp(ext, ".exe") == 0 || Strucmp(ext, ".com") == 0 ||
+       Strucmp(ext, ".cmd") == 0 || Strucmp(ext, ".bat") == 0)) {
     mode |= (_S_IEXEC | (_S_IEXEC >> 3) | (_S_IEXEC >> 6));
   }
 #else
@@ -4258,24 +4240,24 @@ std::string SystemTools::GetOperatingSystemNameAndVersion()
   ZeroMemory(&osvi, sizeof(osvi));
   osvi.dwOSVersionInfoSize = sizeof(osvi);
 
-#ifdef KWSYS_WINDOWS_DEPRECATED_GetVersionEx
-#pragma warning(push)
-#ifdef __INTEL_COMPILER
-#pragma warning(disable : 1478)
-#else
-#pragma warning(disable : 4996)
-#endif
-#endif
+#  ifdef KWSYS_WINDOWS_DEPRECATED_GetVersionEx
+#    pragma warning(push)
+#    ifdef __INTEL_COMPILER
+#      pragma warning(disable : 1478)
+#    else
+#      pragma warning(disable : 4996)
+#    endif
+#  endif
   bOsVersionInfoEx = GetVersionExA((OSVERSIONINFOA*)&osvi);
   if (!bOsVersionInfoEx) {
     return 0;
   }
-#ifdef KWSYS_WINDOWS_DEPRECATED_GetVersionEx
-#pragma warning(pop)
-#endif
+#  ifdef KWSYS_WINDOWS_DEPRECATED_GetVersionEx
+#    pragma warning(pop)
+#  endif
 
   switch (osvi.dwPlatformId) {
-    // Test for the Windows NT product family.
+      // Test for the Windows NT product family.
 
     case VER_PLATFORM_WIN32_NT:
 
@@ -4393,7 +4375,7 @@ std::string SystemTools::GetOperatingSystemNameAndVersion()
 
       else {
         HKEY hKey;
-#define BUFSIZE 80
+#  define BUFSIZE 80
         wchar_t szProductType[BUFSIZE];
         DWORD dwBufLen = BUFSIZE;
         LONG lRet;
@@ -4475,7 +4457,7 @@ std::string SystemTools::GetOperatingSystemNameAndVersion()
 
       break;
 
-    // Test for the Windows 95 product family.
+      // Test for the Windows 95 product family.
 
     case VER_PLATFORM_WIN32_WINDOWS:
 
@@ -4676,9 +4658,9 @@ void SystemTools::ClassFinalize()
 } // namespace KWSYS_NAMESPACE
 
 #if defined(_MSC_VER) && defined(_DEBUG)
-#include <crtdbg.h>
-#include <stdio.h>
-#include <stdlib.h>
+#  include <crtdbg.h>
+#  include <stdio.h>
+#  include <stdlib.h>
 namespace KWSYS_NAMESPACE {
 
 static int SystemToolsDebugReport(int, char* message, int*)
diff --git a/Source/kwsys/SystemTools.hxx.in b/Source/kwsys/SystemTools.hxx.in
index e79e3fcf9..928ee41f2 100644
--- a/Source/kwsys/SystemTools.hxx.in
+++ b/Source/kwsys/SystemTools.hxx.in
@@ -17,7 +17,7 @@
 #include <sys/stat.h>
 
 #if !defined(_WIN32) || defined(__CYGWIN__)
-#include <unistd.h> // For access permissions for use with access()
+#  include <unistd.h> // For access permissions for use with access()
 #endif
 
 // Required for va_list
@@ -318,11 +318,11 @@ public:
  * Cross platform wrapper for stat struct
  */
 #if defined(_WIN32) && !defined(__CYGWIN__)
-#if defined(__BORLANDC__)
+#  if defined(__BORLANDC__)
   typedef struct stati64 Stat_t;
-#else
+#  else
   typedef struct _stat64 Stat_t;
-#endif
+#  endif
 #else
   typedef struct stat Stat_t;
 #endif
@@ -523,9 +523,8 @@ public:
   static bool GetShortPath(const std::string& path, std::string& result);
 
   /**
-   * Read line from file. Make sure to get everything. Due to a buggy stream
-   * library on the HP and another on Mac OS X, we need this very carefully
-   * written version of getline. Returns true if any data were read before the
+   * Read line from file. Make sure to read a full line and truncates it if
+   * requested via sizeLimit. Returns true if any data were read before the
    * end-of-file was reached. If the has_newline argument is specified, it will
    * be true when the line read had a newline character.
    */
diff --git a/Source/kwsys/Terminal.c b/Source/kwsys/Terminal.c
index eaa5c7d43..f0d9c6409 100644
--- a/Source/kwsys/Terminal.c
+++ b/Source/kwsys/Terminal.c
@@ -6,15 +6,15 @@
 /* Work-around CMake dependency scanning limitation.  This must
    duplicate the above list of headers.  */
 #if 0
-#include "Terminal.h.in"
+#  include "Terminal.h.in"
 #endif
 
 /* Configure support for this platform.  */
 #if defined(_WIN32) || defined(__CYGWIN__)
-#define KWSYS_TERMINAL_SUPPORT_CONSOLE
+#  define KWSYS_TERMINAL_SUPPORT_CONSOLE
 #endif
 #if !defined(_WIN32)
-#define KWSYS_TERMINAL_ISATTY_WORKS
+#  define KWSYS_TERMINAL_ISATTY_WORKS
 #endif
 
 /* Include needed system APIs.  */
@@ -24,14 +24,14 @@
 #include <string.h> /* strcmp */
 
 #if defined(KWSYS_TERMINAL_SUPPORT_CONSOLE)
-#include <io.h>      /* _get_osfhandle */
-#include <windows.h> /* SetConsoleTextAttribute */
+#  include <io.h>      /* _get_osfhandle */
+#  include <windows.h> /* SetConsoleTextAttribute */
 #endif
 
 #if defined(KWSYS_TERMINAL_ISATTY_WORKS)
-#include <unistd.h> /* isatty */
+#  include <unistd.h> /* isatty */
 #else
-#include <sys/stat.h> /* fstat */
+#  include <sys/stat.h> /* fstat */
 #endif
 
 static int kwsysTerminalStreamIsVT100(FILE* stream, int default_vt100,
@@ -153,6 +153,7 @@ static const char* kwsysTerminalVT100Names[] = { "Eterm",
                                                  "xterm-88color",
                                                  "xterm-color",
                                                  "xterm-debian",
+                                                 "xterm-kitty",
                                                  "xterm-termite",
                                                  0 };
 
@@ -300,10 +301,12 @@ static void kwsysTerminalSetVT100Color(FILE* stream, int color)
 
 #if defined(KWSYS_TERMINAL_SUPPORT_CONSOLE)
 
-#define KWSYS_TERMINAL_MASK_FOREGROUND                                        \
-  (FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_INTENSITY)
-#define KWSYS_TERMINAL_MASK_BACKGROUND                                        \
-  (BACKGROUND_BLUE | BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_INTENSITY)
+#  define KWSYS_TERMINAL_MASK_FOREGROUND                                      \
+    (FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED |                    \
+     FOREGROUND_INTENSITY)
+#  define KWSYS_TERMINAL_MASK_BACKGROUND                                      \
+    (BACKGROUND_BLUE | BACKGROUND_GREEN | BACKGROUND_RED |                    \
+     BACKGROUND_INTENSITY)
 
 /* Get the Windows handle for a FILE stream.  */
 static HANDLE kwsysTerminalGetStreamHandle(FILE* stream)
@@ -311,7 +314,7 @@ static HANDLE kwsysTerminalGetStreamHandle(FILE* stream)
   /* Get the C-library file descriptor from the stream.  */
   int fd = fileno(stream);
 
-#if defined(__CYGWIN__)
+#  if defined(__CYGWIN__)
   /* Cygwin seems to have an extra pipe level.  If the file descriptor
      corresponds to stdout or stderr then obtain the matching windows
      handle directly.  */
@@ -320,7 +323,7 @@ static HANDLE kwsysTerminalGetStreamHandle(FILE* stream)
   } else if (fd == fileno(stderr)) {
     return GetStdHandle(STD_ERROR_HANDLE);
   }
-#endif
+#  endif
 
   /* Get the underlying Windows handle for the descriptor.  */
   return (HANDLE)_get_osfhandle(fd);
diff --git a/Source/kwsys/Terminal.h.in b/Source/kwsys/Terminal.h.in
index 5d2983004..1a2c7452f 100644
--- a/Source/kwsys/Terminal.h.in
+++ b/Source/kwsys/Terminal.h.in
@@ -12,57 +12,57 @@
    not visible to user code.  Use kwsysHeaderDump.pl to reproduce
    these macros after making changes to the interface.  */
 #if !defined(KWSYS_NAMESPACE)
-#define kwsys_ns(x) @KWSYS_NAMESPACE@##x
-#define kwsysEXPORT @KWSYS_NAMESPACE@_EXPORT
+#  define kwsys_ns(x) @KWSYS_NAMESPACE@##x
+#  define kwsysEXPORT @KWSYS_NAMESPACE@_EXPORT
 #endif
 #if !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
-#define kwsysTerminal_cfprintf kwsys_ns(Terminal_cfprintf)
-#define kwsysTerminal_Color_e kwsys_ns(Terminal_Color_e)
-#define kwsysTerminal_Color_Normal kwsys_ns(Terminal_Color_Normal)
-#define kwsysTerminal_Color_ForegroundBlack                                   \
-  kwsys_ns(Terminal_Color_ForegroundBlack)
-#define kwsysTerminal_Color_ForegroundRed                                     \
-  kwsys_ns(Terminal_Color_ForegroundRed)
-#define kwsysTerminal_Color_ForegroundGreen                                   \
-  kwsys_ns(Terminal_Color_ForegroundGreen)
-#define kwsysTerminal_Color_ForegroundYellow                                  \
-  kwsys_ns(Terminal_Color_ForegroundYellow)
-#define kwsysTerminal_Color_ForegroundBlue                                    \
-  kwsys_ns(Terminal_Color_ForegroundBlue)
-#define kwsysTerminal_Color_ForegroundMagenta                                 \
-  kwsys_ns(Terminal_Color_ForegroundMagenta)
-#define kwsysTerminal_Color_ForegroundCyan                                    \
-  kwsys_ns(Terminal_Color_ForegroundCyan)
-#define kwsysTerminal_Color_ForegroundWhite                                   \
-  kwsys_ns(Terminal_Color_ForegroundWhite)
-#define kwsysTerminal_Color_ForegroundMask                                    \
-  kwsys_ns(Terminal_Color_ForegroundMask)
-#define kwsysTerminal_Color_BackgroundBlack                                   \
-  kwsys_ns(Terminal_Color_BackgroundBlack)
-#define kwsysTerminal_Color_BackgroundRed                                     \
-  kwsys_ns(Terminal_Color_BackgroundRed)
-#define kwsysTerminal_Color_BackgroundGreen                                   \
-  kwsys_ns(Terminal_Color_BackgroundGreen)
-#define kwsysTerminal_Color_BackgroundYellow                                  \
-  kwsys_ns(Terminal_Color_BackgroundYellow)
-#define kwsysTerminal_Color_BackgroundBlue                                    \
-  kwsys_ns(Terminal_Color_BackgroundBlue)
-#define kwsysTerminal_Color_BackgroundMagenta                                 \
-  kwsys_ns(Terminal_Color_BackgroundMagenta)
-#define kwsysTerminal_Color_BackgroundCyan                                    \
-  kwsys_ns(Terminal_Color_BackgroundCyan)
-#define kwsysTerminal_Color_BackgroundWhite                                   \
-  kwsys_ns(Terminal_Color_BackgroundWhite)
-#define kwsysTerminal_Color_BackgroundMask                                    \
-  kwsys_ns(Terminal_Color_BackgroundMask)
-#define kwsysTerminal_Color_ForegroundBold                                    \
-  kwsys_ns(Terminal_Color_ForegroundBold)
-#define kwsysTerminal_Color_BackgroundBold                                    \
-  kwsys_ns(Terminal_Color_BackgroundBold)
-#define kwsysTerminal_Color_AssumeTTY kwsys_ns(Terminal_Color_AssumeTTY)
-#define kwsysTerminal_Color_AssumeVT100 kwsys_ns(Terminal_Color_AssumeVT100)
-#define kwsysTerminal_Color_AttributeMask                                     \
-  kwsys_ns(Terminal_Color_AttributeMask)
+#  define kwsysTerminal_cfprintf kwsys_ns(Terminal_cfprintf)
+#  define kwsysTerminal_Color_e kwsys_ns(Terminal_Color_e)
+#  define kwsysTerminal_Color_Normal kwsys_ns(Terminal_Color_Normal)
+#  define kwsysTerminal_Color_ForegroundBlack                                 \
+    kwsys_ns(Terminal_Color_ForegroundBlack)
+#  define kwsysTerminal_Color_ForegroundRed                                   \
+    kwsys_ns(Terminal_Color_ForegroundRed)
+#  define kwsysTerminal_Color_ForegroundGreen                                 \
+    kwsys_ns(Terminal_Color_ForegroundGreen)
+#  define kwsysTerminal_Color_ForegroundYellow                                \
+    kwsys_ns(Terminal_Color_ForegroundYellow)
+#  define kwsysTerminal_Color_ForegroundBlue                                  \
+    kwsys_ns(Terminal_Color_ForegroundBlue)
+#  define kwsysTerminal_Color_ForegroundMagenta                               \
+    kwsys_ns(Terminal_Color_ForegroundMagenta)
+#  define kwsysTerminal_Color_ForegroundCyan                                  \
+    kwsys_ns(Terminal_Color_ForegroundCyan)
+#  define kwsysTerminal_Color_ForegroundWhite                                 \
+    kwsys_ns(Terminal_Color_ForegroundWhite)
+#  define kwsysTerminal_Color_ForegroundMask                                  \
+    kwsys_ns(Terminal_Color_ForegroundMask)
+#  define kwsysTerminal_Color_BackgroundBlack                                 \
+    kwsys_ns(Terminal_Color_BackgroundBlack)
+#  define kwsysTerminal_Color_BackgroundRed                                   \
+    kwsys_ns(Terminal_Color_BackgroundRed)
+#  define kwsysTerminal_Color_BackgroundGreen                                 \
+    kwsys_ns(Terminal_Color_BackgroundGreen)
+#  define kwsysTerminal_Color_BackgroundYellow                                \
+    kwsys_ns(Terminal_Color_BackgroundYellow)
+#  define kwsysTerminal_Color_BackgroundBlue                                  \
+    kwsys_ns(Terminal_Color_BackgroundBlue)
+#  define kwsysTerminal_Color_BackgroundMagenta                               \
+    kwsys_ns(Terminal_Color_BackgroundMagenta)
+#  define kwsysTerminal_Color_BackgroundCyan                                  \
+    kwsys_ns(Terminal_Color_BackgroundCyan)
+#  define kwsysTerminal_Color_BackgroundWhite                                 \
+    kwsys_ns(Terminal_Color_BackgroundWhite)
+#  define kwsysTerminal_Color_BackgroundMask                                  \
+    kwsys_ns(Terminal_Color_BackgroundMask)
+#  define kwsysTerminal_Color_ForegroundBold                                  \
+    kwsys_ns(Terminal_Color_ForegroundBold)
+#  define kwsysTerminal_Color_BackgroundBold                                  \
+    kwsys_ns(Terminal_Color_BackgroundBold)
+#  define kwsysTerminal_Color_AssumeTTY kwsys_ns(Terminal_Color_AssumeTTY)
+#  define kwsysTerminal_Color_AssumeVT100 kwsys_ns(Terminal_Color_AssumeVT100)
+#  define kwsysTerminal_Color_AttributeMask                                   \
+    kwsys_ns(Terminal_Color_AttributeMask)
 #endif
 
 #if defined(__cplusplus)
@@ -135,36 +135,36 @@ enum kwsysTerminal_Color_e
 /* If we are building a kwsys .c or .cxx file, let it use these macros.
    Otherwise, undefine them to keep the namespace clean.  */
 #if !defined(KWSYS_NAMESPACE)
-#undef kwsys_ns
-#undef kwsysEXPORT
-#if !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
-#undef kwsysTerminal_cfprintf
-#undef kwsysTerminal_Color_e
-#undef kwsysTerminal_Color_Normal
-#undef kwsysTerminal_Color_ForegroundBlack
-#undef kwsysTerminal_Color_ForegroundRed
-#undef kwsysTerminal_Color_ForegroundGreen
-#undef kwsysTerminal_Color_ForegroundYellow
-#undef kwsysTerminal_Color_ForegroundBlue
-#undef kwsysTerminal_Color_ForegroundMagenta
-#undef kwsysTerminal_Color_ForegroundCyan
-#undef kwsysTerminal_Color_ForegroundWhite
-#undef kwsysTerminal_Color_ForegroundMask
-#undef kwsysTerminal_Color_BackgroundBlack
-#undef kwsysTerminal_Color_BackgroundRed
-#undef kwsysTerminal_Color_BackgroundGreen
-#undef kwsysTerminal_Color_BackgroundYellow
-#undef kwsysTerminal_Color_BackgroundBlue
-#undef kwsysTerminal_Color_BackgroundMagenta
-#undef kwsysTerminal_Color_BackgroundCyan
-#undef kwsysTerminal_Color_BackgroundWhite
-#undef kwsysTerminal_Color_BackgroundMask
-#undef kwsysTerminal_Color_ForegroundBold
-#undef kwsysTerminal_Color_BackgroundBold
-#undef kwsysTerminal_Color_AssumeTTY
-#undef kwsysTerminal_Color_AssumeVT100
-#undef kwsysTerminal_Color_AttributeMask
-#endif
+#  undef kwsys_ns
+#  undef kwsysEXPORT
+#  if !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
+#    undef kwsysTerminal_cfprintf
+#    undef kwsysTerminal_Color_e
+#    undef kwsysTerminal_Color_Normal
+#    undef kwsysTerminal_Color_ForegroundBlack
+#    undef kwsysTerminal_Color_ForegroundRed
+#    undef kwsysTerminal_Color_ForegroundGreen
+#    undef kwsysTerminal_Color_ForegroundYellow
+#    undef kwsysTerminal_Color_ForegroundBlue
+#    undef kwsysTerminal_Color_ForegroundMagenta
+#    undef kwsysTerminal_Color_ForegroundCyan
+#    undef kwsysTerminal_Color_ForegroundWhite
+#    undef kwsysTerminal_Color_ForegroundMask
+#    undef kwsysTerminal_Color_BackgroundBlack
+#    undef kwsysTerminal_Color_BackgroundRed
+#    undef kwsysTerminal_Color_BackgroundGreen
+#    undef kwsysTerminal_Color_BackgroundYellow
+#    undef kwsysTerminal_Color_BackgroundBlue
+#    undef kwsysTerminal_Color_BackgroundMagenta
+#    undef kwsysTerminal_Color_BackgroundCyan
+#    undef kwsysTerminal_Color_BackgroundWhite
+#    undef kwsysTerminal_Color_BackgroundMask
+#    undef kwsysTerminal_Color_ForegroundBold
+#    undef kwsysTerminal_Color_BackgroundBold
+#    undef kwsysTerminal_Color_AssumeTTY
+#    undef kwsysTerminal_Color_AssumeVT100
+#    undef kwsysTerminal_Color_AttributeMask
+#  endif
 #endif
 
 #endif
diff --git a/Source/kwsys/hash_map.hxx.in b/Source/kwsys/hash_map.hxx.in
index 8c9b81e1b..5f04e9c16 100644
--- a/Source/kwsys/hash_map.hxx.in
+++ b/Source/kwsys/hash_map.hxx.in
@@ -35,14 +35,14 @@
 #include <functional> // equal_to
 
 #if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable : 4284)
-#pragma warning(disable : 4786)
+#  pragma warning(push)
+#  pragma warning(disable : 4284)
+#  pragma warning(disable : 4786)
 #endif
 
 #if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
-#pragma set woff 1174
-#pragma set woff 1375
+#  pragma set woff 1174
+#  pragma set woff 1375
 #endif
 
 namespace @KWSYS_NAMESPACE@ {
@@ -412,12 +412,12 @@ inline void swap(hash_multimap<_Key, _Tp, _HashFcn, _EqlKey, _Alloc>& __hm1,
 } // namespace @KWSYS_NAMESPACE@
 
 #if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
-#pragma reset woff 1174
-#pragma reset woff 1375
+#  pragma reset woff 1174
+#  pragma reset woff 1375
 #endif
 
 #if defined(_MSC_VER)
-#pragma warning(pop)
+#  pragma warning(pop)
 #endif
 
 #endif
diff --git a/Source/kwsys/hash_set.hxx.in b/Source/kwsys/hash_set.hxx.in
index 5edd367af..f4a37eebd 100644
--- a/Source/kwsys/hash_set.hxx.in
+++ b/Source/kwsys/hash_set.hxx.in
@@ -35,14 +35,14 @@
 #include <functional> // equal_to
 
 #if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable : 4284)
-#pragma warning(disable : 4786)
+#  pragma warning(push)
+#  pragma warning(disable : 4284)
+#  pragma warning(disable : 4786)
 #endif
 
 #if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
-#pragma set woff 1174
-#pragma set woff 1375
+#  pragma set woff 1174
+#  pragma set woff 1375
 #endif
 
 namespace @KWSYS_NAMESPACE@ {
@@ -381,12 +381,12 @@ inline void swap(hash_multiset<_Val, _HashFcn, _EqualKey, _Alloc>& __hs1,
 } // namespace @KWSYS_NAMESPACE@
 
 #if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
-#pragma reset woff 1174
-#pragma reset woff 1375
+#  pragma reset woff 1174
+#  pragma reset woff 1375
 #endif
 
 #if defined(_MSC_VER)
-#pragma warning(pop)
+#  pragma warning(pop)
 #endif
 
 #endif
diff --git a/Source/kwsys/hashtable.hxx.in b/Source/kwsys/hashtable.hxx.in
index e962f17a9..fc0d60e7d 100644
--- a/Source/kwsys/hashtable.hxx.in
+++ b/Source/kwsys/hashtable.hxx.in
@@ -26,42 +26,42 @@
  *
  */
 #ifdef __BORLANDC__
-#pragma warn - 8027 /* 'for' not inlined.  */
-#pragma warn - 8026 /* 'exception' not inlined.  */
+#  pragma warn - 8027 /* 'for' not inlined.  */
+#  pragma warn - 8026 /* 'exception' not inlined.  */
 #endif
 
 #ifndef @KWSYS_NAMESPACE@_hashtable_hxx
-#define @KWSYS_NAMESPACE@_hashtable_hxx
-
-#include <@KWSYS_NAMESPACE@/Configure.hxx>
-
-#include <algorithm> // lower_bound
-#include <iterator>  // iterator_traits
-#include <memory>    // allocator
-#include <stddef.h>  // size_t
-#include <utility>   // pair
-#include <vector>    // vector
-
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable : 4284)
-#pragma warning(disable : 4786)
-#pragma warning(disable : 4512) /* no assignment operator for class */
-#endif
-#if defined(__sgi) && !defined(__GNUC__)
-#pragma set woff 3970 /* pointer to int conversion */ 3321 3968
-#endif
+#  define @KWSYS_NAMESPACE@_hashtable_hxx
+
+#  include <@KWSYS_NAMESPACE@/Configure.hxx>
+
+#  include <algorithm> // lower_bound
+#  include <iterator>  // iterator_traits
+#  include <memory>    // allocator
+#  include <stddef.h>  // size_t
+#  include <utility>   // pair
+#  include <vector>    // vector
+
+#  if defined(_MSC_VER)
+#    pragma warning(push)
+#    pragma warning(disable : 4284)
+#    pragma warning(disable : 4786)
+#    pragma warning(disable : 4512) /* no assignment operator for class */
+#  endif
+#  if defined(__sgi) && !defined(__GNUC__)
+#    pragma set woff 3970 /* pointer to int conversion */ 3321 3968
+#  endif
 
 // In C++11, clang will warn about using dynamic exception specifications
 // as they are deprecated.  But as this class is trying to faithfully
 // mimic unordered_set and unordered_map, we want to keep the 'throw()'
 // decorations below.  So we suppress the warning.
-#if defined(__clang__) && defined(__has_warning)
-#if __has_warning("-Wdeprecated")
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdeprecated"
-#endif
-#endif
+#  if defined(__clang__) && defined(__has_warning)
+#    if __has_warning("-Wdeprecated")
+#      pragma clang diagnostic push
+#      pragma clang diagnostic ignored "-Wdeprecated"
+#    endif
+#  endif
 
 namespace @KWSYS_NAMESPACE@ {
 
@@ -250,6 +250,7 @@ private:
 public:
   typedef typename _Alloc::template rebind<_Val>::other allocator_type;
   allocator_type get_allocator() const { return _M_node_allocator; }
+
 private:
   typedef
     typename _Alloc::template rebind<_Node>::other _M_node_allocator_type;
@@ -568,7 +569,7 @@ private:
 template <class _Val, class _Key, class _HF, class _ExK, class _EqK,
           class _All>
 _Hashtable_iterator<_Val, _Key, _HF, _ExK, _EqK, _All>&
-  _Hashtable_iterator<_Val, _Key, _HF, _ExK, _EqK, _All>::operator++()
+_Hashtable_iterator<_Val, _Key, _HF, _ExK, _EqK, _All>::operator++()
 {
   const _Node* __old = _M_cur;
   _M_cur = _M_cur->_M_next;
@@ -583,7 +584,7 @@ _Hashtable_iterator<_Val, _Key, _HF, _ExK, _EqK, _All>&
 template <class _Val, class _Key, class _HF, class _ExK, class _EqK,
           class _All>
 inline _Hashtable_iterator<_Val, _Key, _HF, _ExK, _EqK, _All>
-  _Hashtable_iterator<_Val, _Key, _HF, _ExK, _EqK, _All>::operator++(int)
+_Hashtable_iterator<_Val, _Key, _HF, _ExK, _EqK, _All>::operator++(int)
 {
   iterator __tmp = *this;
   ++*this;
@@ -593,7 +594,7 @@ inline _Hashtable_iterator<_Val, _Key, _HF, _ExK, _EqK, _All>
 template <class _Val, class _Key, class _HF, class _ExK, class _EqK,
           class _All>
 _Hashtable_const_iterator<_Val, _Key, _HF, _ExK, _EqK, _All>&
-  _Hashtable_const_iterator<_Val, _Key, _HF, _ExK, _EqK, _All>::operator++()
+_Hashtable_const_iterator<_Val, _Key, _HF, _ExK, _EqK, _All>::operator++()
 {
   const _Node* __old = _M_cur;
   _M_cur = _M_cur->_M_next;
@@ -608,7 +609,7 @@ _Hashtable_const_iterator<_Val, _Key, _HF, _ExK, _EqK, _All>&
 template <class _Val, class _Key, class _HF, class _ExK, class _EqK,
           class _All>
 inline _Hashtable_const_iterator<_Val, _Key, _HF, _ExK, _EqK, _All>
-  _Hashtable_const_iterator<_Val, _Key, _HF, _ExK, _EqK, _All>::operator++(int)
+_Hashtable_const_iterator<_Val, _Key, _HF, _ExK, _EqK, _All>::operator++(int)
 {
   const_iterator __tmp = *this;
   ++*this;
@@ -693,8 +694,9 @@ hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::insert_equal_noresize(
 }
 
 template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
-typename hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::reference hashtable<
-  _Val, _Key, _HF, _Ex, _Eq, _All>::find_or_insert(const value_type& __obj)
+typename hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::reference
+hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::find_or_insert(
+  const value_type& __obj)
 {
   resize(_M_num_elements + 1);
 
@@ -962,7 +964,7 @@ void hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::_M_copy_from(
         _Node* __copy = _M_new_node(__cur->_M_val);
         _M_buckets[__i] = __copy;
 
-        for (_Node *__next = __cur->_M_next; __next;
+        for (_Node* __next = __cur->_M_next; __next;
              __cur = __next, __next = __cur->_M_next) {
           __copy->_M_next = _M_new_node(__next->_M_val);
           __copy = __copy->_M_next;
@@ -979,14 +981,14 @@ void hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::_M_copy_from(
 } // namespace @KWSYS_NAMESPACE@
 
 // Undo warning suppression.
-#if defined(__clang__) && defined(__has_warning)
-#if __has_warning("-Wdeprecated")
-#pragma clang diagnostic pop
-#endif
-#endif
-
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
+#  if defined(__clang__) && defined(__has_warning)
+#    if __has_warning("-Wdeprecated")
+#      pragma clang diagnostic pop
+#    endif
+#  endif
+
+#  if defined(_MSC_VER)
+#    pragma warning(pop)
+#  endif
 
 #endif
diff --git a/Source/kwsys/kwsysPlatformTestsC.c b/Source/kwsys/kwsysPlatformTestsC.c
index 5432633eb..b0cf7ad3b 100644
--- a/Source/kwsys/kwsysPlatformTestsC.c
+++ b/Source/kwsys/kwsysPlatformTestsC.c
@@ -17,18 +17,18 @@
     }
 */
 #if defined(__CLASSIC_C__)
-#define KWSYS_PLATFORM_TEST_C_MAIN() main()
-#define KWSYS_PLATFORM_TEST_C_MAIN_ARGS(argc, argv)                           \
-  main(argc, argv) int argc;                                                  \
-  char* argv[];
+#  define KWSYS_PLATFORM_TEST_C_MAIN() main()
+#  define KWSYS_PLATFORM_TEST_C_MAIN_ARGS(argc, argv)                         \
+    main(argc, argv) int argc;                                                \
+    char* argv[];
 #else
-#define KWSYS_PLATFORM_TEST_C_MAIN() main(void)
-#define KWSYS_PLATFORM_TEST_C_MAIN_ARGS(argc, argv)                           \
-  main(int argc, char* argv[])
+#  define KWSYS_PLATFORM_TEST_C_MAIN() main(void)
+#  define KWSYS_PLATFORM_TEST_C_MAIN_ARGS(argc, argv)                         \
+    main(int argc, char* argv[])
 #endif
 
 #ifdef TEST_KWSYS_C_HAS_PTRDIFF_T
-#include <stddef.h>
+#  include <stddef.h>
 int f(ptrdiff_t n)
 {
   return n > 0;
@@ -43,7 +43,7 @@ int KWSYS_PLATFORM_TEST_C_MAIN()
 #endif
 
 #ifdef TEST_KWSYS_C_HAS_SSIZE_T
-#include <unistd.h>
+#  include <unistd.h>
 int f(ssize_t n)
 {
   return (int)n;
@@ -56,13 +56,13 @@ int KWSYS_PLATFORM_TEST_C_MAIN()
 #endif
 
 #ifdef TEST_KWSYS_C_HAS_CLOCK_GETTIME_MONOTONIC
-#if defined(__APPLE__)
-#include <AvailabilityMacros.h>
-#if MAC_OS_X_VERSION_MIN_REQUIRED < 101200
-#error "clock_gettime not available on macOS < 10.12"
-#endif
-#endif
-#include <time.h>
+#  if defined(__APPLE__)
+#    include <AvailabilityMacros.h>
+#    if MAC_OS_X_VERSION_MIN_REQUIRED < 101200
+#      error "clock_gettime not available on macOS < 10.12"
+#    endif
+#  endif
+#  include <time.h>
 int KWSYS_PLATFORM_TEST_C_MAIN()
 {
   struct timespec ts;
@@ -72,30 +72,30 @@ int KWSYS_PLATFORM_TEST_C_MAIN()
 
 #ifdef TEST_KWSYS_C_TYPE_MACROS
 char* info_macros =
-#if defined(__SIZEOF_SHORT__)
+#  if defined(__SIZEOF_SHORT__)
   "INFO:macro[__SIZEOF_SHORT__]\n"
-#endif
-#if defined(__SIZEOF_INT__)
+#  endif
+#  if defined(__SIZEOF_INT__)
   "INFO:macro[__SIZEOF_INT__]\n"
-#endif
-#if defined(__SIZEOF_LONG__)
+#  endif
+#  if defined(__SIZEOF_LONG__)
   "INFO:macro[__SIZEOF_LONG__]\n"
-#endif
-#if defined(__SIZEOF_LONG_LONG__)
+#  endif
+#  if defined(__SIZEOF_LONG_LONG__)
   "INFO:macro[__SIZEOF_LONG_LONG__]\n"
-#endif
-#if defined(__SHORT_MAX__)
+#  endif
+#  if defined(__SHORT_MAX__)
   "INFO:macro[__SHORT_MAX__]\n"
-#endif
-#if defined(__INT_MAX__)
+#  endif
+#  if defined(__INT_MAX__)
   "INFO:macro[__INT_MAX__]\n"
-#endif
-#if defined(__LONG_MAX__)
+#  endif
+#  if defined(__LONG_MAX__)
   "INFO:macro[__LONG_MAX__]\n"
-#endif
-#if defined(__LONG_LONG_MAX__)
+#  endif
+#  if defined(__LONG_LONG_MAX__)
   "INFO:macro[__LONG_LONG_MAX__]\n"
-#endif
+#  endif
   "";
 
 int KWSYS_PLATFORM_TEST_C_MAIN_ARGS(argc, argv)
diff --git a/Source/kwsys/kwsysPlatformTestsCXX.cxx b/Source/kwsys/kwsysPlatformTestsCXX.cxx
index f1f9ed351..b77d7292a 100644
--- a/Source/kwsys/kwsysPlatformTestsCXX.cxx
+++ b/Source/kwsys/kwsysPlatformTestsCXX.cxx
@@ -1,7 +1,7 @@
 /* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
    file Copyright.txt or https://cmake.org/licensing#kwsys for details.  */
 #ifdef TEST_KWSYS_CXX_HAS_CSTDIO
-#include <cstdio>
+#  include <cstdio>
 int main()
 {
   return 0;
@@ -33,10 +33,10 @@ int main()
 #endif
 
 #ifdef TEST_KWSYS_CXX_STAT_HAS_ST_MTIM
-#include <sys/types.h>
+#  include <sys/types.h>
 
-#include <sys/stat.h>
-#include <unistd.h>
+#  include <sys/stat.h>
+#  include <unistd.h>
 int main()
 {
   struct stat stat1;
@@ -47,10 +47,10 @@ int main()
 #endif
 
 #ifdef TEST_KWSYS_CXX_STAT_HAS_ST_MTIMESPEC
-#include <sys/types.h>
+#  include <sys/types.h>
 
-#include <sys/stat.h>
-#include <unistd.h>
+#  include <sys/stat.h>
+#  include <unistd.h>
 int main()
 {
   struct stat stat1;
@@ -85,7 +85,7 @@ int main()
 #endif
 
 #ifdef TEST_KWSYS_IOS_HAS_ISTREAM_LONG_LONG
-#include <iostream>
+#  include <iostream>
 int test_istream(std::istream& is, long long& x)
 {
   return (is >> x) ? 1 : 0;
@@ -98,7 +98,7 @@ int main()
 #endif
 
 #ifdef TEST_KWSYS_IOS_HAS_OSTREAM_LONG_LONG
-#include <iostream>
+#  include <iostream>
 int test_ostream(std::ostream& os, long long x)
 {
   return (os << x) ? 1 : 0;
@@ -111,7 +111,7 @@ int main()
 #endif
 
 #ifdef TEST_KWSYS_IOS_HAS_ISTREAM___INT64
-#include <iostream>
+#  include <iostream>
 int test_istream(std::istream& is, __int64& x)
 {
   return (is >> x) ? 1 : 0;
@@ -124,7 +124,7 @@ int main()
 #endif
 
 #ifdef TEST_KWSYS_IOS_HAS_OSTREAM___INT64
-#include <iostream>
+#  include <iostream>
 int test_ostream(std::ostream& os, __int64 x)
 {
   return (os << x) ? 1 : 0;
@@ -138,23 +138,23 @@ int main()
 
 #ifdef TEST_KWSYS_LFS_WORKS
 /* Return 0 when LFS is available and 1 otherwise.  */
-#define _LARGEFILE_SOURCE
-#define _LARGEFILE64_SOURCE
-#define _LARGE_FILES
-#define _FILE_OFFSET_BITS 64
-#include <sys/types.h>
-
-#include <assert.h>
-#include <sys/stat.h>
-#if KWSYS_CXX_HAS_CSTDIO
-#include <cstdio>
-#endif
-#include <stdio.h>
+#  define _LARGEFILE_SOURCE
+#  define _LARGEFILE64_SOURCE
+#  define _LARGE_FILES
+#  define _FILE_OFFSET_BITS 64
+#  include <sys/types.h>
+
+#  include <assert.h>
+#  include <sys/stat.h>
+#  if KWSYS_CXX_HAS_CSTDIO
+#    include <cstdio>
+#  endif
+#  include <stdio.h>
 
 int main(int, char** argv)
 {
 /* check that off_t can hold 2^63 - 1 and perform basic operations... */
-#define OFF_T_64 (((off_t)1 << 62) - 1 + ((off_t)1 << 62))
+#  define OFF_T_64 (((off_t)1 << 62) - 1 + ((off_t)1 << 62))
   if (OFF_T_64 % 2147483647 != 1)
     return 1;
 
@@ -173,7 +173,7 @@ int main(int, char** argv)
 #endif
 
 #ifdef TEST_KWSYS_CXX_HAS_SETENV
-#include <stdlib.h>
+#  include <stdlib.h>
 int main()
 {
   return setenv("A", "B", 1);
@@ -181,7 +181,7 @@ int main()
 #endif
 
 #ifdef TEST_KWSYS_CXX_HAS_UNSETENV
-#include <stdlib.h>
+#  include <stdlib.h>
 int main()
 {
   unsetenv("A");
@@ -190,7 +190,7 @@ int main()
 #endif
 
 #ifdef TEST_KWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H
-#include <stdlib.h>
+#  include <stdlib.h>
 int main()
 {
   char* e = environ[0];
@@ -200,10 +200,10 @@ int main()
 
 #ifdef TEST_KWSYS_CXX_HAS_GETLOADAVG
 // Match feature definitions from SystemInformation.cxx
-#if (defined(__GNUC__) || defined(__PGI)) && !defined(_GNU_SOURCE)
-#define _GNU_SOURCE
-#endif
-#include <stdlib.h>
+#  if (defined(__GNUC__) || defined(__PGI)) && !defined(_GNU_SOURCE)
+#    define _GNU_SOURCE
+#  endif
+#  include <stdlib.h>
 int main()
 {
   double loadavg[3] = { 0.0, 0.0, 0.0 };
@@ -212,13 +212,13 @@ int main()
 #endif
 
 #ifdef TEST_KWSYS_CXX_HAS_RLIMIT64
-#if defined(KWSYS_HAS_LFS)
-#define _LARGEFILE_SOURCE
-#define _LARGEFILE64_SOURCE
-#define _LARGE_FILES
-#define _FILE_OFFSET_BITS 64
-#endif
-#include <sys/resource.h>
+#  if defined(KWSYS_HAS_LFS)
+#    define _LARGEFILE_SOURCE
+#    define _LARGEFILE64_SOURCE
+#    define _LARGE_FILES
+#    define _FILE_OFFSET_BITS 64
+#  endif
+#  include <sys/resource.h>
 int main()
 {
   struct rlimit64 rlim;
@@ -227,7 +227,7 @@ int main()
 #endif
 
 #ifdef TEST_KWSYS_CXX_HAS_ATOLL
-#include <stdlib.h>
+#  include <stdlib.h>
 int main()
 {
   const char* str = "1024";
@@ -236,7 +236,7 @@ int main()
 #endif
 
 #ifdef TEST_KWSYS_CXX_HAS_ATOL
-#include <stdlib.h>
+#  include <stdlib.h>
 int main()
 {
   const char* str = "1024";
@@ -245,7 +245,7 @@ int main()
 #endif
 
 #ifdef TEST_KWSYS_CXX_HAS__ATOI64
-#include <stdlib.h>
+#  include <stdlib.h>
 int main()
 {
   const char* str = "1024";
@@ -254,7 +254,7 @@ int main()
 #endif
 
 #ifdef TEST_KWSYS_CXX_HAS_UTIMES
-#include <sys/time.h>
+#  include <sys/time.h>
 int main()
 {
   struct timeval* current_time = 0;
@@ -263,14 +263,14 @@ int main()
 #endif
 
 #ifdef TEST_KWSYS_CXX_HAS_UTIMENSAT
-#include <fcntl.h>
-#include <sys/stat.h>
-#if defined(__APPLE__)
-#include <AvailabilityMacros.h>
-#if MAC_OS_X_VERSION_MIN_REQUIRED < 101300
-#error "utimensat not available on macOS < 10.13"
-#endif
-#endif
+#  include <fcntl.h>
+#  include <sys/stat.h>
+#  if defined(__APPLE__)
+#    include <AvailabilityMacros.h>
+#    if MAC_OS_X_VERSION_MIN_REQUIRED < 101300
+#      error "utimensat not available on macOS < 10.13"
+#    endif
+#  endif
 int main()
 {
   struct timespec times[2] = { { 0, UTIME_OMIT }, { 0, UTIME_NOW } };
@@ -279,14 +279,14 @@ int main()
 #endif
 
 #ifdef TEST_KWSYS_CXX_HAS_BACKTRACE
-#if defined(__PATHSCALE__) || defined(__PATHCC__) ||                          \
-  (defined(__LSB_VERSION__) && (__LSB_VERSION__ < 41))
+#  if defined(__PATHSCALE__) || defined(__PATHCC__) ||                        \
+    (defined(__LSB_VERSION__) && (__LSB_VERSION__ < 41))
 backtrace does not work with this compiler or os
-#endif
-#if (defined(__GNUC__) || defined(__PGI)) && !defined(_GNU_SOURCE)
-#define _GNU_SOURCE
-#endif
-#include <execinfo.h>
+#  endif
+#  if (defined(__GNUC__) || defined(__PGI)) && !defined(_GNU_SOURCE)
+#    define _GNU_SOURCE
+#  endif
+#  include <execinfo.h>
 int main()
 {
   void* stackSymbols[256];
@@ -297,10 +297,10 @@ int main()
 #endif
 
 #ifdef TEST_KWSYS_CXX_HAS_DLADDR
-#if (defined(__GNUC__) || defined(__PGI)) && !defined(_GNU_SOURCE)
-#define _GNU_SOURCE
-#endif
-#include <dlfcn.h>
+#  if (defined(__GNUC__) || defined(__PGI)) && !defined(_GNU_SOURCE)
+#    define _GNU_SOURCE
+#  endif
+#  include <dlfcn.h>
 int main()
 {
   Dl_info info;
@@ -310,14 +310,14 @@ int main()
 #endif
 
 #ifdef TEST_KWSYS_CXX_HAS_CXXABI
-#if (defined(__GNUC__) || defined(__PGI)) && !defined(_GNU_SOURCE)
-#define _GNU_SOURCE
-#endif
-#if defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x5130 && __linux &&               \
-  __SUNPRO_CC_COMPAT == 'G'
-#include <iostream>
-#endif
-#include <cxxabi.h>
+#  if (defined(__GNUC__) || defined(__PGI)) && !defined(_GNU_SOURCE)
+#    define _GNU_SOURCE
+#  endif
+#  if defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x5130 && __linux &&             \
+    __SUNPRO_CC_COMPAT == 'G'
+#    include <iostream>
+#  endif
+#  include <cxxabi.h>
 int main()
 {
   int status = 0;
@@ -358,7 +358,7 @@ int main()
 #endif
 
 #ifdef TEST_KWSYS_STL_HAS_WSTRING
-#include <string>
+#  include <string>
 void f(std::wstring*)
 {
 }
@@ -369,7 +369,7 @@ int main()
 #endif
 
 #ifdef TEST_KWSYS_CXX_HAS_EXT_STDIO_FILEBUF_H
-#include <ext/stdio_filebuf.h>
+#  include <ext/stdio_filebuf.h>
 int main()
 {
   return 0;
diff --git a/Source/kwsys/kwsysPrivate.h b/Source/kwsys/kwsysPrivate.h
index ce1b53ed8..dd9c1277f 100644
--- a/Source/kwsys/kwsysPrivate.h
+++ b/Source/kwsys/kwsysPrivate.h
@@ -1,11 +1,11 @@
 /* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
    file Copyright.txt or https://cmake.org/licensing#kwsys for details.  */
 #ifndef KWSYS_NAMESPACE
-#error "Do not include kwsysPrivate.h outside of kwsys c and cxx files."
+#  error "Do not include kwsysPrivate.h outside of kwsys c and cxx files."
 #endif
 
 #ifndef _kwsysPrivate_h
-#define _kwsysPrivate_h
+#  define _kwsysPrivate_h
 
 /*
   Define KWSYS_HEADER macro to help the c and cxx files include kwsys
@@ -18,17 +18,17 @@
 /* clang-format off */
 #define KWSYS_HEADER(x) KWSYS_HEADER0(KWSYS_NAMESPACE/x)
 /* clang-format on */
-#define KWSYS_HEADER0(x) KWSYS_HEADER1(x)
-#define KWSYS_HEADER1(x) <x>
+#  define KWSYS_HEADER0(x) KWSYS_HEADER1(x)
+#  define KWSYS_HEADER1(x) <x>
 
 /*
   Define KWSYS_NAMESPACE_STRING to be a string constant containing the
   name configured for this instance of the kwsys library.
 */
-#define KWSYS_NAMESPACE_STRING KWSYS_NAMESPACE_STRING0(KWSYS_NAMESPACE)
-#define KWSYS_NAMESPACE_STRING0(x) KWSYS_NAMESPACE_STRING1(x)
-#define KWSYS_NAMESPACE_STRING1(x) #x
+#  define KWSYS_NAMESPACE_STRING KWSYS_NAMESPACE_STRING0(KWSYS_NAMESPACE)
+#  define KWSYS_NAMESPACE_STRING0(x) KWSYS_NAMESPACE_STRING1(x)
+#  define KWSYS_NAMESPACE_STRING1(x) #  x
 
 #else
-#error "kwsysPrivate.h included multiple times."
+#  error "kwsysPrivate.h included multiple times."
 #endif
diff --git a/Source/kwsys/testCommandLineArguments.cxx b/Source/kwsys/testCommandLineArguments.cxx
index 78baed97a..0385a3dc6 100644
--- a/Source/kwsys/testCommandLineArguments.cxx
+++ b/Source/kwsys/testCommandLineArguments.cxx
@@ -6,7 +6,7 @@
 // Work-around CMake dependency scanning limitation.  This must
 // duplicate the above list of headers.
 #if 0
-#include "CommandLineArguments.hxx.in"
+#  include "CommandLineArguments.hxx.in"
 #endif
 
 #include <iostream>
@@ -136,7 +136,7 @@ int testCommandLineArguments(int argc, char* argv[])
   arg.AddCallback("-C", argT::EQUAL_ARGUMENT, argument, random_ptr,
                   "Option -C takes argument after =");
   arg.AddCallback("-D", argT::CONCAT_ARGUMENT, argument, random_ptr,
-                  "This option takes concatinated argument");
+                  "This option takes concatenated argument");
   arg.AddCallback("--long1", argT::NO_ARGUMENT, argument, random_ptr, "-A");
   arg.AddCallback("--long2", argT::SPACE_ARGUMENT, argument, random_ptr, "-B");
   arg.AddCallback("--long3", argT::EQUAL_ARGUMENT, argument, random_ptr,
diff --git a/Source/kwsys/testCommandLineArguments1.cxx b/Source/kwsys/testCommandLineArguments1.cxx
index 5dfa5e3f3..9895008f0 100644
--- a/Source/kwsys/testCommandLineArguments1.cxx
+++ b/Source/kwsys/testCommandLineArguments1.cxx
@@ -6,7 +6,7 @@
 // Work-around CMake dependency scanning limitation.  This must
 // duplicate the above list of headers.
 #if 0
-#include "CommandLineArguments.hxx.in"
+#  include "CommandLineArguments.hxx.in"
 #endif
 
 #include <iostream>
diff --git a/Source/kwsys/testConfigure.cxx b/Source/kwsys/testConfigure.cxx
index 916dcc135..a3c2ed3ae 100644
--- a/Source/kwsys/testConfigure.cxx
+++ b/Source/kwsys/testConfigure.cxx
@@ -6,7 +6,7 @@ file Copyright.txt or https://cmake.org/licensing#kwsys for details.  */
 // Work-around CMake dependency scanning limitation.  This must
 // duplicate the above list of headers.
 #if 0
-#include "Configure.hxx.in"
+#  include "Configure.hxx.in"
 #endif
 
 static bool testFallthrough(int n)
diff --git a/Source/kwsys/testConsoleBuf.cxx b/Source/kwsys/testConsoleBuf.cxx
index 816a4338e..154944058 100644
--- a/Source/kwsys/testConsoleBuf.cxx
+++ b/Source/kwsys/testConsoleBuf.cxx
@@ -13,24 +13,24 @@
 // Work-around CMake dependency scanning limitation.  This must
 // duplicate the above list of headers.
 #if 0
-#include "Encoding.hxx.in"
+#  include "Encoding.hxx.in"
 #endif
 
 #if defined(_WIN32)
 
-#include <algorithm>
-#include <iomanip>
-#include <iostream>
-#include <stdexcept>
-#include <string.h>
-#include <wchar.h>
-#include <windows.h>
+#  include <algorithm>
+#  include <iomanip>
+#  include <iostream>
+#  include <stdexcept>
+#  include <string.h>
+#  include <wchar.h>
+#  include <windows.h>
 
-#include "testConsoleBuf.hxx"
+#  include "testConsoleBuf.hxx"
 
-#if defined(_MSC_VER) && _MSC_VER >= 1800
-#define KWSYS_WINDOWS_DEPRECATED_GetVersion
-#endif
+#  if defined(_MSC_VER) && _MSC_VER >= 1800
+#    define KWSYS_WINDOWS_DEPRECATED_GetVersion
+#  endif
 // يونيكود
 static const WCHAR UnicodeInputTestString[] =
   L"\u064A\u0648\u0646\u064A\u0643\u0648\u062F!";
@@ -219,9 +219,9 @@ static void finishFile(HANDLE file)
   }
 }
 
-#ifndef MAPVK_VK_TO_VSC
-#define MAPVK_VK_TO_VSC (0)
-#endif
+#  ifndef MAPVK_VK_TO_VSC
+#    define MAPVK_VK_TO_VSC (0)
+#  endif
 
 static void writeInputKeyEvent(INPUT_RECORD inputBuffer[], WCHAR chr)
 {
@@ -470,9 +470,9 @@ static int testFile()
   return didFail;
 }
 
-#ifndef _WIN32_WINNT_VISTA
-#define _WIN32_WINNT_VISTA 0x0600
-#endif
+#  ifndef _WIN32_WINNT_VISTA
+#    define _WIN32_WINNT_VISTA 0x0600
+#  endif
 
 static int testConsole()
 {
@@ -495,19 +495,19 @@ static int testConsole()
   DWORD FaceNameSize = sizeof(FaceName);
   DWORD FontFamily = TestFontFamily;
   DWORD FontSize = TestFontSize;
-#ifdef KWSYS_WINDOWS_DEPRECATED_GetVersion
-#pragma warning(push)
-#ifdef __INTEL_COMPILER
-#pragma warning(disable : 1478)
-#else
-#pragma warning(disable : 4996)
-#endif
-#endif
+#  ifdef KWSYS_WINDOWS_DEPRECATED_GetVersion
+#    pragma warning(push)
+#    ifdef __INTEL_COMPILER
+#      pragma warning(disable : 1478)
+#    else
+#      pragma warning(disable : 4996)
+#    endif
+#  endif
   const bool isVistaOrGreater =
     LOBYTE(LOWORD(GetVersion())) >= HIBYTE(_WIN32_WINNT_VISTA);
-#ifdef KWSYS_WINDOWS_DEPRECATED_GetVersion
-#pragma warning(pop)
-#endif
+#  ifdef KWSYS_WINDOWS_DEPRECATED_GetVersion
+#    pragma warning(pop)
+#  endif
   if (!isVistaOrGreater) {
     if (RegOpenKeyExW(HKEY_CURRENT_USER, L"Console", 0, KEY_READ | KEY_WRITE,
                       &hConsoleKey) == ERROR_SUCCESS) {
@@ -573,7 +573,7 @@ static int testConsole()
     newConsole = true;
   }
 
-#if _WIN32_WINNT >= _WIN32_WINNT_VISTA
+#  if _WIN32_WINNT >= _WIN32_WINNT_VISTA
   if (isVistaOrGreater) {
     CONSOLE_FONT_INFOEX consoleFont;
     memset(&consoleFont, 0, sizeof(consoleFont));
@@ -603,7 +603,7 @@ static int testConsole()
       std::cerr << "GetCurrentConsoleFontEx failed!" << std::endl;
     }
   } else {
-#endif
+#  endif
     if (restoreConsole &&
         RegOpenKeyExW(HKEY_CURRENT_USER, L"Console", 0, KEY_WRITE,
                       &hConsoleKey) == ERROR_SUCCESS) {
@@ -619,9 +619,9 @@ static int testConsole()
                      sizeof(FontSize));
       RegCloseKey(hConsoleKey);
     }
-#if _WIN32_WINNT >= _WIN32_WINNT_VISTA
+#  if _WIN32_WINNT >= _WIN32_WINNT_VISTA
   }
-#endif
+#  endif
 
   if (createProcess(NULL, NULL, NULL)) {
     try {
diff --git a/Source/kwsys/testConsoleBufChild.cxx b/Source/kwsys/testConsoleBufChild.cxx
index 6a743edcd..3c8fdc2e1 100644
--- a/Source/kwsys/testConsoleBufChild.cxx
+++ b/Source/kwsys/testConsoleBufChild.cxx
@@ -8,8 +8,8 @@
 // Work-around CMake dependency scanning limitation.  This must
 // duplicate the above list of headers.
 #if 0
-#include "ConsoleBuf.hxx.in"
-#include "Encoding.hxx.in"
+#  include "ConsoleBuf.hxx.in"
+#  include "Encoding.hxx.in"
 #endif
 
 #include <iostream>
diff --git a/Source/kwsys/testDirectory.cxx b/Source/kwsys/testDirectory.cxx
index 983f2c631..b1ab0c872 100644
--- a/Source/kwsys/testDirectory.cxx
+++ b/Source/kwsys/testDirectory.cxx
@@ -8,9 +8,9 @@ file Copyright.txt or https://cmake.org/licensing#kwsys for details.  */
 // Work-around CMake dependency scanning limitation.  This must
 // duplicate the above list of headers.
 #if 0
-#include "Directory.hxx.in"
-#include "Encoding.hxx.in"
-#include "SystemTools.hxx.in"
+#  include "Directory.hxx.in"
+#  include "Encoding.hxx.in"
+#  include "SystemTools.hxx.in"
 #endif
 
 #include <fstream>
@@ -73,7 +73,38 @@ int _doLongPathTest()
   return res;
 }
 
+int _copyDirectoryTest()
+{
+  using namespace kwsys;
+  const std::string source(TEST_SYSTEMTOOLS_BINARY_DIR
+                           "/directory_testing/copyDirectoryTestSrc");
+  if (SystemTools::PathExists(source)) {
+    std::cerr << source << " shouldn't exist before test" << std::endl;
+    return 1;
+  }
+  const std::string destination(TEST_SYSTEMTOOLS_BINARY_DIR
+                                "/directory_testing/copyDirectoryTestDst");
+  if (SystemTools::PathExists(destination)) {
+    std::cerr << destination << " shouldn't exist before test" << std::endl;
+    return 2;
+  }
+  const bool copysuccess = SystemTools::CopyADirectory(source, destination);
+  const bool destinationexists = SystemTools::PathExists(destination);
+  if (copysuccess) {
+    std::cerr << "CopyADirectory should have returned false" << std::endl;
+    SystemTools::RemoveADirectory(destination);
+    return 3;
+  }
+  if (destinationexists) {
+    std::cerr << "CopyADirectory returned false, but destination directory"
+              << " has been created" << std::endl;
+    SystemTools::RemoveADirectory(destination);
+    return 4;
+  }
+  return 0;
+}
+
 int testDirectory(int, char* [])
 {
-  return _doLongPathTest();
+  return _doLongPathTest() + _copyDirectoryTest();
 }
diff --git a/Source/kwsys/testDynamicLoader.cxx b/Source/kwsys/testDynamicLoader.cxx
index b52ddda8b..ce87117a1 100644
--- a/Source/kwsys/testDynamicLoader.cxx
+++ b/Source/kwsys/testDynamicLoader.cxx
@@ -5,13 +5,13 @@
 #include KWSYS_HEADER(DynamicLoader.hxx)
 
 #if defined(__BEOS__) || defined(__HAIKU__)
-#include <be/kernel/OS.h> /* disable_debugger() API. */
+#  include <be/kernel/OS.h> /* disable_debugger() API. */
 #endif
 
 // Work-around CMake dependency scanning limitation.  This must
 // duplicate the above list of headers.
 #if 0
-#include "DynamicLoader.hxx.in"
+#  include "DynamicLoader.hxx.in"
 #endif
 
 #include <iostream>
diff --git a/Source/kwsys/testDynload.c b/Source/kwsys/testDynload.c
index cdb9e5c35..c49f747df 100644
--- a/Source/kwsys/testDynload.c
+++ b/Source/kwsys/testDynload.c
@@ -1,9 +1,9 @@
 /* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
    file Copyright.txt or https://cmake.org/licensing#kwsys for details.  */
 #ifdef _WIN32
-#define DL_EXPORT __declspec(dllexport)
+#  define DL_EXPORT __declspec(dllexport)
 #else
-#define DL_EXPORT
+#  define DL_EXPORT
 #endif
 
 DL_EXPORT int TestDynamicLoaderData = 0;
diff --git a/Source/kwsys/testEncode.c b/Source/kwsys/testEncode.c
index a20d46fd3..b7b6dd845 100644
--- a/Source/kwsys/testEncode.c
+++ b/Source/kwsys/testEncode.c
@@ -6,7 +6,7 @@
 /* Work-around CMake dependency scanning limitation.  This must
    duplicate the above list of headers.  */
 #if 0
-#include "MD5.h.in"
+#  include "MD5.h.in"
 #endif
 
 #include <stdio.h>
diff --git a/Source/kwsys/testEncoding.cxx b/Source/kwsys/testEncoding.cxx
index 6bf273f2c..fdad1cdff 100644
--- a/Source/kwsys/testEncoding.cxx
+++ b/Source/kwsys/testEncoding.cxx
@@ -3,7 +3,7 @@
 #include "kwsysPrivate.h"
 
 #if defined(_MSC_VER)
-#pragma warning(disable : 4786)
+#  pragma warning(disable : 4786)
 #endif
 
 #include KWSYS_HEADER(Encoding.hxx)
@@ -18,8 +18,8 @@
 // Work-around CMake dependency scanning limitation.  This must
 // duplicate the above list of headers.
 #if 0
-#include "Encoding.h.in"
-#include "Encoding.hxx.in"
+#  include "Encoding.h.in"
+#  include "Encoding.hxx.in"
 #endif
 
 static const unsigned char helloWorldStrings[][32] = {
diff --git a/Source/kwsys/testFStream.cxx b/Source/kwsys/testFStream.cxx
index a92a781c3..5009e9887 100644
--- a/Source/kwsys/testFStream.cxx
+++ b/Source/kwsys/testFStream.cxx
@@ -3,19 +3,19 @@
 #include "kwsysPrivate.h"
 
 #if defined(_MSC_VER)
-#pragma warning(disable : 4786)
+#  pragma warning(disable : 4786)
 #endif
 
 #include KWSYS_HEADER(FStream.hxx)
 #include <string.h>
 #ifdef __BORLANDC__
-#include <mem.h> /* memcmp */
+#  include <mem.h> /* memcmp */
 #endif
 
 // Work-around CMake dependency scanning limitation.  This must
 // duplicate the above list of headers.
 #if 0
-#include "FStream.hxx.in"
+#  include "FStream.hxx.in"
 #endif
 
 #include <iostream>
diff --git a/Source/kwsys/testHashSTL.cxx b/Source/kwsys/testHashSTL.cxx
index 044487473..4ed2f899d 100644
--- a/Source/kwsys/testHashSTL.cxx
+++ b/Source/kwsys/testHashSTL.cxx
@@ -7,18 +7,19 @@
 // Work-around CMake dependency scanning limitation.  This must
 // duplicate the above list of headers.
 #if 0
-#include "hash_map.hxx.in"
-#include "hash_set.hxx.in"
+#  include "hash_map.hxx.in"
+#  include "hash_set.hxx.in"
 #endif
 
 #include <iostream>
 
 #if defined(_MSC_VER)
-#pragma warning(disable : 4786)
+#  pragma warning(disable : 4786)
 #endif
 
 #if defined(__sgi) && !defined(__GNUC__)
-#pragma set woff 1468 /* inline function cannot be explicitly instantiated */
+#  pragma set woff 1468 /* inline function cannot be explicitly instantiated  \
+                         */
 #endif
 
 template class kwsys::hash_map<const char*, int>;
diff --git a/Source/kwsys/testProcess.c b/Source/kwsys/testProcess.c
index 4b4978dfe..f139f5860 100644
--- a/Source/kwsys/testProcess.c
+++ b/Source/kwsys/testProcess.c
@@ -7,8 +7,8 @@
 /* Work-around CMake dependency scanning limitation.  This must
    duplicate the above list of headers.  */
 #if 0
-#include "Encoding.h.in"
-#include "Process.h.in"
+#  include "Encoding.h.in"
+#  include "Process.h.in"
 #endif
 
 #include <assert.h>
@@ -18,21 +18,21 @@
 #include <string.h>
 
 #if defined(_WIN32)
-#include <windows.h>
+#  include <windows.h>
 #else
-#include <signal.h>
-#include <unistd.h>
+#  include <signal.h>
+#  include <unistd.h>
 #endif
 
 #if defined(__BORLANDC__)
-#pragma warn - 8060 /* possibly incorrect assignment */
+#  pragma warn - 8060 /* possibly incorrect assignment */
 #endif
 
 /* Platform-specific sleep functions. */
 
 #if defined(__BEOS__) && !defined(__ZETA__)
 /* BeOS 5 doesn't have usleep(), but it has snooze(), which is identical. */
-#include <be/kernel/OS.h>
+#  include <be/kernel/OS.h>
 static inline void testProcess_usleep(unsigned int usec)
 {
   snooze(usec);
@@ -44,7 +44,7 @@ static void testProcess_usleep(unsigned int usec)
   Sleep(usec / 1000);
 }
 #else
-#define testProcess_usleep usleep
+#  define testProcess_usleep usleep
 #endif
 
 #if defined(_WIN32)
@@ -481,20 +481,23 @@ static int runChild2(kwsysProcess* kp, const char* cmd[], int state,
 
   if (result) {
     if (exception != kwsysProcess_GetExitException(kp)) {
-      fprintf(stderr, "Mismatch in exit exception.  "
-                      "Should have been %d, was %d.\n",
+      fprintf(stderr,
+              "Mismatch in exit exception.  "
+              "Should have been %d, was %d.\n",
               exception, kwsysProcess_GetExitException(kp));
     }
     if (value != kwsysProcess_GetExitValue(kp)) {
-      fprintf(stderr, "Mismatch in exit value.  "
-                      "Should have been %d, was %d.\n",
+      fprintf(stderr,
+              "Mismatch in exit value.  "
+              "Should have been %d, was %d.\n",
               value, kwsysProcess_GetExitValue(kp));
     }
   }
 
   if (kwsysProcess_GetState(kp) != state) {
-    fprintf(stderr, "Mismatch in state.  "
-                    "Should have been %d, was %d.\n",
+    fprintf(stderr,
+            "Mismatch in state.  "
+            "Should have been %d, was %d.\n",
             state, kwsysProcess_GetState(kp));
     result = 1;
   }
diff --git a/Source/kwsys/testSharedForward.c.in b/Source/kwsys/testSharedForward.c.in
index 9a0c0c061..b3eb41382 100644
--- a/Source/kwsys/testSharedForward.c.in
+++ b/Source/kwsys/testSharedForward.c.in
@@ -1,11 +1,11 @@
 /* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
    file Copyright.txt or https://cmake.org/licensing#kwsys for details.  */
 #if defined(CMAKE_INTDIR)
-#define CONFIG_DIR_PRE CMAKE_INTDIR "/"
-#define CONFIG_DIR_POST "/" CMAKE_INTDIR
+#  define CONFIG_DIR_PRE CMAKE_INTDIR "/"
+#  define CONFIG_DIR_POST "/" CMAKE_INTDIR
 #else
-#define CONFIG_DIR_PRE ""
-#define CONFIG_DIR_POST ""
+#  define CONFIG_DIR_PRE ""
+#  define CONFIG_DIR_POST ""
 #endif
 #define @KWSYS_NAMESPACE@_SHARED_FORWARD_DIR_BUILD "@EXEC_DIR@"
 #define @KWSYS_NAMESPACE@_SHARED_FORWARD_PATH_BUILD "." CONFIG_DIR_POST
@@ -18,7 +18,7 @@
 #define @KWSYS_NAMESPACE@_SHARED_FORWARD_OPTION_PRINT "--print"
 #define @KWSYS_NAMESPACE@_SHARED_FORWARD_OPTION_LDD "--ldd"
 #if defined(CMAKE_INTDIR)
-#define @KWSYS_NAMESPACE@_SHARED_FORWARD_CONFIG_NAME CMAKE_INTDIR
+#  define @KWSYS_NAMESPACE@_SHARED_FORWARD_CONFIG_NAME CMAKE_INTDIR
 #endif
 #include <@KWSYS_NAMESPACE@/SharedForward.h>
 int main(int argc, char** argv)
diff --git a/Source/kwsys/testSystemInformation.cxx b/Source/kwsys/testSystemInformation.cxx
index 3a9217f2c..154517eae 100644
--- a/Source/kwsys/testSystemInformation.cxx
+++ b/Source/kwsys/testSystemInformation.cxx
@@ -6,25 +6,25 @@
 // Work-around CMake dependency scanning limitation.  This must
 // duplicate the above list of headers.
 #if 0
-#include "SystemInformation.hxx.in"
+#  include "SystemInformation.hxx.in"
 #endif
 
 #include <iostream>
 
 #if defined(KWSYS_USE_LONG_LONG)
-#if defined(KWSYS_IOS_HAS_OSTREAM_LONG_LONG)
-#define iostreamLongLong(x) (x)
-#else
-#define iostreamLongLong(x) ((long)x)
-#endif
+#  if defined(KWSYS_IOS_HAS_OSTREAM_LONG_LONG)
+#    define iostreamLongLong(x) (x)
+#  else
+#    define iostreamLongLong(x) ((long)x)
+#  endif
 #elif defined(KWSYS_USE___INT64)
-#if defined(KWSYS_IOS_HAS_OSTREAM___INT64)
-#define iostreamLongLong(x) (x)
+#  if defined(KWSYS_IOS_HAS_OSTREAM___INT64)
+#    define iostreamLongLong(x) (x)
+#  else
+#    define iostreamLongLong(x) ((long)x)
+#  endif
 #else
-#define iostreamLongLong(x) ((long)x)
-#endif
-#else
-#error "No Long Long"
+#  error "No Long Long"
 #endif
 
 #define printMethod(info, m) std::cout << #m << ": " << info.m() << "\n"
@@ -86,7 +86,7 @@ int testSystemInformation(int, char* [])
   }
 
   /* test stack trace
-  */
+   */
   std::cout << "Program Stack:" << std::endl
             << kwsys::SystemInformation::GetProgramStack(0, 0) << std::endl
             << std::endl;
diff --git a/Source/kwsys/testSystemTools.cxx b/Source/kwsys/testSystemTools.cxx
index e436a2b26..e6f9701c3 100644
--- a/Source/kwsys/testSystemTools.cxx
+++ b/Source/kwsys/testSystemTools.cxx
@@ -3,7 +3,7 @@
 #include "kwsysPrivate.h"
 
 #if defined(_MSC_VER)
-#pragma warning(disable : 4786)
+#  pragma warning(disable : 4786)
 #endif
 
 #include KWSYS_HEADER(FStream.hxx)
@@ -12,8 +12,8 @@
 // Work-around CMake dependency scanning limitation.  This must
 // duplicate the above list of headers.
 #if 0
-#include "FStream.hxx.in"
-#include "SystemTools.hxx.in"
+#  include "FStream.hxx.in"
+#  include "SystemTools.hxx.in"
 #endif
 
 // Include with <> instead of "" to avoid getting any in-source copy
@@ -25,10 +25,10 @@
 #include <stdlib.h> /* free */
 #include <string.h> /* strcmp */
 #if defined(_WIN32) && !defined(__CYGWIN__)
-#include <io.h> /* _umask (MSVC) / umask (Borland) */
-#ifdef _MSC_VER
-#define umask _umask // Note this is still umask on Borland
-#endif
+#  include <io.h> /* _umask (MSVC) / umask (Borland) */
+#  ifdef _MSC_VER
+#    define umask _umask // Note this is still umask on Borland
+#  endif
 #endif
 #include <sys/stat.h> /* umask (POSIX), _S_I* constants (Windows) */
 // Visual C++ does not define mode_t (note that Borland does, however).
@@ -738,29 +738,29 @@ static bool CheckGetPath()
 #endif
   const char* registryPath = "[HKEY_LOCAL_MACHINE\\SOFTWARE\\MyApp; MyKey]";
 
-  std::vector<std::string> originalPathes;
-  originalPathes.push_back(registryPath);
+  std::vector<std::string> originalPaths;
+  originalPaths.push_back(registryPath);
 
-  std::vector<std::string> expectedPathes;
-  expectedPathes.push_back(registryPath);
+  std::vector<std::string> expectedPaths;
+  expectedPaths.push_back(registryPath);
 #ifdef _WIN32
-  expectedPathes.push_back("C:/Somewhere/something");
-  expectedPathes.push_back("D:/Temp");
+  expectedPaths.push_back("C:/Somewhere/something");
+  expectedPaths.push_back("D:/Temp");
 #else
-  expectedPathes.push_back("/Somewhere/something");
-  expectedPathes.push_back("/tmp");
+  expectedPaths.push_back("/Somewhere/something");
+  expectedPaths.push_back("/tmp");
 #endif
 
   bool res = true;
   res &= CheckPutEnv(std::string(envName) + "=" + envValue, envName, envValue);
 
-  std::vector<std::string> pathes = originalPathes;
-  kwsys::SystemTools::GetPath(pathes, envName);
+  std::vector<std::string> paths = originalPaths;
+  kwsys::SystemTools::GetPath(paths, envName);
 
-  if (pathes != expectedPathes) {
-    std::cerr << "GetPath(" << StringVectorToString(originalPathes) << ", "
-              << envName << ")  yielded " << StringVectorToString(pathes)
-              << " instead of " << StringVectorToString(expectedPathes)
+  if (paths != expectedPaths) {
+    std::cerr << "GetPath(" << StringVectorToString(originalPaths) << ", "
+              << envName << ")  yielded " << StringVectorToString(paths)
+              << " instead of " << StringVectorToString(expectedPaths)
               << std::endl;
     res = false;
   }
@@ -912,6 +912,78 @@ static bool CheckGetLineFromStream()
   return ret;
 }
 
+static bool CheckGetLineFromStreamLongLine()
+{
+  const std::string fileWithLongLine("longlines.txt");
+  std::string firstLine, secondLine;
+  // First line: large buffer, containing a carriage return for some reason.
+  firstLine.assign(2050, ' ');
+  firstLine += "\rfirst";
+  secondLine.assign(2050, 'y');
+  secondLine += "second";
+
+  // Create file with long lines.
+  {
+    kwsys::ofstream out(fileWithLongLine.c_str(), std::ios::binary);
+    if (!out) {
+      std::cerr << "Problem opening for write: " << fileWithLongLine
+                << std::endl;
+      return false;
+    }
+    out << firstLine << "\r\n\n" << secondLine << "\n";
+  }
+
+  kwsys::ifstream file(fileWithLongLine.c_str(), std::ios::binary);
+  if (!file) {
+    std::cerr << "Problem opening: " << fileWithLongLine << std::endl;
+    return false;
+  }
+
+  std::string line;
+  bool has_newline = false;
+  bool result;
+
+  // Read first line.
+  result = kwsys::SystemTools::GetLineFromStream(file, line, &has_newline, -1);
+  if (!result || line != firstLine) {
+    std::cerr << "First line does not match, expected " << firstLine.size()
+              << " characters, got " << line.size() << std::endl;
+    return false;
+  }
+  if (!has_newline) {
+    std::cerr << "Expected new line to be read from first line" << std::endl;
+    return false;
+  }
+
+  // Read empty line.
+  has_newline = false;
+  result = kwsys::SystemTools::GetLineFromStream(file, line, &has_newline, -1);
+  if (!result || !line.empty()) {
+    std::cerr << "Expected successful read with an empty line, got "
+              << line.size() << " characters" << std::endl;
+    return false;
+  }
+  if (!has_newline) {
+    std::cerr << "Expected new line to be read for an empty line" << std::endl;
+    return false;
+  }
+
+  // Read second line.
+  has_newline = false;
+  result = kwsys::SystemTools::GetLineFromStream(file, line, &has_newline, -1);
+  if (!result || line != secondLine) {
+    std::cerr << "Second line does not match, expected " << secondLine.size()
+              << " characters, got " << line.size() << std::endl;
+    return false;
+  }
+  if (!has_newline) {
+    std::cerr << "Expected new line to be read from second line" << std::endl;
+    return false;
+  }
+
+  return true;
+}
+
 int testSystemTools(int, char* [])
 {
   bool res = true;
@@ -951,6 +1023,8 @@ int testSystemTools(int, char* [])
 
   res &= CheckGetLineFromStream();
 
+  res &= CheckGetLineFromStreamLongLine();
+
   res &= CheckGetFilenameName();
 
   return res ? 0 : 1;
diff --git a/Source/kwsys/testTerminal.c b/Source/kwsys/testTerminal.c
index f6c1eddb7..652830ccd 100644
--- a/Source/kwsys/testTerminal.c
+++ b/Source/kwsys/testTerminal.c
@@ -6,7 +6,7 @@
 /* Work-around CMake dependency scanning limitation.  This must
    duplicate the above list of headers.  */
 #if 0
-#include "Terminal.h.in"
+#  include "Terminal.h.in"
 #endif
 
 int testTerminal(int argc, char* argv[])