Code style: add missed explicit 'this->'

CMake uses explicit 'this->' style. Using custom clang-tidy check we can
detect and fix places where 'this->' was missed.

127 files changed, 5221 insertions, 4575 deletions

diff --git a/Source/CPack/IFW/cmCPackIFWInstaller.cxx b/Source/CPack/IFW/cmCPackIFWInstaller.cxx
index 8e00ad686c..359fc56b15 100644
--- a/Source/CPack/IFW/cmCPackIFWInstaller.cxx
+++ b/Source/CPack/IFW/cmCPackIFWInstaller.cxx
@@ -66,7 +66,7 @@ void cmCPackIFWInstaller::ConfigureFromOptions()
         this->GetOption("CPACK_IFW_PACKAGE_PUBLISHER")) {
     this->Publisher = optIFW_PACKAGE_PUBLISHER;
   } else if (const char* optPACKAGE_VENDOR =
-               GetOption("CPACK_PACKAGE_VENDOR")) {
+               this->GetOption("CPACK_PACKAGE_VENDOR")) {
     this->Publisher = optPACKAGE_VENDOR;
   }
 
@@ -204,7 +204,7 @@ void cmCPackIFWInstaller::ConfigureFromOptions()
         this->GetOption("CPACK_IFW_PACKAGE_START_MENU_DIRECTORY")) {
     this->StartMenuDir = optIFW_START_MENU_DIR;
   } else {
-    this->StartMenuDir = Name;
+    this->StartMenuDir = this->Name;
   }
 
   // Default target directory for installation
@@ -303,7 +303,7 @@ protected:
   void StartElement(const std::string& name, const char** /*atts*/) override
   {
     this->file = name == "file";
-    if (file) {
+    if (this->file) {
       this->hasFiles = true;
     }
   }
@@ -337,7 +337,7 @@ void cmCPackIFWInstaller::GenerateInstallerFile()
 
   xout.StartDocument();
 
-  WriteGeneratedByToStrim(xout);
+  this->WriteGeneratedByToStrim(xout);
 
   xout.StartElement("Installer");
 
@@ -535,7 +535,7 @@ void cmCPackIFWInstaller::GeneratePackageFiles()
       package.ConfigureFromGroup(option);
       std::string forcedOption = "CPACK_IFW_COMPONENT_GROUP_" +
         cmsys::SystemTools::UpperCase(option) + "_FORCED_INSTALLATION";
-      if (!GetOption(forcedOption)) {
+      if (!this->GetOption(forcedOption)) {
         package.ForcedInstallation = "true";
       }
     } else {
diff --git a/Source/CPack/IFW/cmCPackIFWPackage.cxx b/Source/CPack/IFW/cmCPackIFWPackage.cxx
index 56a74c58b9..c4bd7f115b 100644
--- a/Source/CPack/IFW/cmCPackIFWPackage.cxx
+++ b/Source/CPack/IFW/cmCPackIFWPackage.cxx
@@ -337,7 +337,7 @@ int cmCPackIFWPackage::ConfigureFromGroup(const std::string& groupName)
 
   group.Name = groupName;
 
-  if (Generator) {
+  if (this->Generator) {
     this->Name = this->Generator->GetGroupPackageName(&group);
   } else {
     this->Name = group.Name;
@@ -530,7 +530,7 @@ void cmCPackIFWPackage::GeneratePackageFile()
 
   xout.StartDocument();
 
-  WriteGeneratedByToStrim(xout);
+  this->WriteGeneratedByToStrim(xout);
 
   xout.StartElement("Package");
 
@@ -577,7 +577,7 @@ void cmCPackIFWPackage::GeneratePackageFile()
   }
 
   // User Interfaces (copy to meta dir)
-  std::vector<std::string> userInterfaces = UserInterfaces;
+  std::vector<std::string> userInterfaces = this->UserInterfaces;
   for (std::string& userInterface : userInterfaces) {
     std::string name = cmSystemTools::GetFilenameName(userInterface);
     std::string path = this->Directory + "/meta/" + name;
@@ -593,7 +593,7 @@ void cmCPackIFWPackage::GeneratePackageFile()
   }
 
   // Translations (copy to meta dir)
-  std::vector<std::string> translations = Translations;
+  std::vector<std::string> translations = this->Translations;
   for (std::string& translation : translations) {
     std::string name = cmSystemTools::GetFilenameName(translation);
     std::string path = this->Directory + "/meta/" + name;
diff --git a/Source/CPack/IFW/cmCPackIFWPackage.h b/Source/CPack/IFW/cmCPackIFWPackage.h
index dbd554054a..0cc6f2fdf8 100644
--- a/Source/CPack/IFW/cmCPackIFWPackage.h
+++ b/Source/CPack/IFW/cmCPackIFWPackage.h
@@ -53,7 +53,7 @@ public:
 
     bool operator<(const DependenceStruct& other) const
     {
-      return Name < other.Name;
+      return this->Name < other.Name;
     }
   };
 
diff --git a/Source/CPack/IFW/cmCPackIFWRepository.cxx b/Source/CPack/IFW/cmCPackIFWRepository.cxx
index f5e87443be..12879075a7 100644
--- a/Source/CPack/IFW/cmCPackIFWRepository.cxx
+++ b/Source/CPack/IFW/cmCPackIFWRepository.cxx
@@ -46,9 +46,9 @@ bool cmCPackIFWRepository::ConfigureFromOptions()
   // Update
   if (this->IsOn(prefix + "ADD")) {
     this->Update = cmCPackIFWRepository::Add;
-  } else if (IsOn(prefix + "REMOVE")) {
+  } else if (this->IsOn(prefix + "REMOVE")) {
     this->Update = cmCPackIFWRepository::Remove;
-  } else if (IsOn(prefix + "REPLACE")) {
+  } else if (this->IsOn(prefix + "REPLACE")) {
     this->Update = cmCPackIFWRepository::Replace;
   } else {
     this->Update = cmCPackIFWRepository::None;
@@ -247,7 +247,7 @@ void cmCPackIFWRepository::WriteRepositoryUpdate(cmXMLWriter& xout)
   if (this->Update == cmCPackIFWRepository::Add ||
       this->Update == cmCPackIFWRepository::Remove) {
     xout.Attribute("url", this->Url);
-  } else if (Update == cmCPackIFWRepository::Replace) {
+  } else if (this->Update == cmCPackIFWRepository::Replace) {
     xout.Attribute("oldUrl", this->OldUrl);
     xout.Attribute("newUrl", this->NewUrl);
   }
diff --git a/Source/CPack/cmCPackArchiveGenerator.cxx b/Source/CPack/cmCPackArchiveGenerator.cxx
index 967cc6060f..5348f86959 100644
--- a/Source/CPack/cmCPackArchiveGenerator.cxx
+++ b/Source/CPack/cmCPackArchiveGenerator.cxx
@@ -80,10 +80,10 @@ std::string cmCPackArchiveGenerator::GetArchiveComponentFileName(
     packageFileName +=
       this->GetOption("CPACK_ARCHIVE_" + componentUpper + "_FILE_NAME");
   } else if (this->IsSet("CPACK_ARCHIVE_FILE_NAME")) {
-    packageFileName += GetComponentPackageFileName(
+    packageFileName += this->GetComponentPackageFileName(
       this->GetOption("CPACK_ARCHIVE_FILE_NAME"), component, isGroupName);
   } else {
-    packageFileName += GetComponentPackageFileName(
+    packageFileName += this->GetComponentPackageFileName(
       this->GetOption("CPACK_PACKAGE_FILE_NAME"), component, isGroupName);
   }
 
@@ -181,7 +181,7 @@ int cmCPackArchiveGenerator::addOneComponentToArchive(
 
 int cmCPackArchiveGenerator::PackageComponents(bool ignoreGroup)
 {
-  packageFileNames.clear();
+  this->packageFileNames.clear();
   // The default behavior is to have one package by component group
   // unless CPACK_COMPONENTS_IGNORE_GROUP is specified.
   if (!ignoreGroup) {
@@ -189,7 +189,7 @@ int cmCPackArchiveGenerator::PackageComponents(bool ignoreGroup)
       cmCPackLogger(cmCPackLog::LOG_VERBOSE,
                     "Packaging component group: " << compG.first << std::endl);
       // Begin the archive for this group
-      std::string packageFileName = std::string(toplevel) + "/" +
+      std::string packageFileName = std::string(this->toplevel) + "/" +
         this->GetArchiveComponentFileName(compG.first, true);
 
       // open a block in order to automatically close archive
@@ -199,11 +199,11 @@ int cmCPackArchiveGenerator::PackageComponents(bool ignoreGroup)
         // now iterate over the component of this group
         for (cmCPackComponent* comp : (compG.second).Components) {
           // Add the files of this component to the archive
-          addOneComponentToArchive(archive, comp);
+          this->addOneComponentToArchive(archive, comp);
         }
       }
       // add the generated package to package file names list
-      packageFileNames.push_back(std::move(packageFileName));
+      this->packageFileNames.push_back(std::move(packageFileName));
     }
     // Handle Orphan components (components not belonging to any groups)
     for (auto& comp : this->Components) {
@@ -217,7 +217,7 @@ int cmCPackArchiveGenerator::PackageComponents(bool ignoreGroup)
             << std::endl);
         std::string localToplevel(
           this->GetOption("CPACK_TEMPORARY_DIRECTORY"));
-        std::string packageFileName = std::string(toplevel);
+        std::string packageFileName = std::string(this->toplevel);
 
         localToplevel += "/" + comp.first;
         packageFileName +=
@@ -226,10 +226,10 @@ int cmCPackArchiveGenerator::PackageComponents(bool ignoreGroup)
         {
           DECLARE_AND_OPEN_ARCHIVE(packageFileName, archive);
           // Add the files of this component to the archive
-          addOneComponentToArchive(archive, &(comp.second));
+          this->addOneComponentToArchive(archive, &(comp.second));
         }
         // add the generated package to package file names list
-        packageFileNames.push_back(std::move(packageFileName));
+        this->packageFileNames.push_back(std::move(packageFileName));
       }
     }
   }
@@ -238,7 +238,7 @@ int cmCPackArchiveGenerator::PackageComponents(bool ignoreGroup)
   else {
     for (auto& comp : this->Components) {
       std::string localToplevel(this->GetOption("CPACK_TEMPORARY_DIRECTORY"));
-      std::string packageFileName = std::string(toplevel);
+      std::string packageFileName = std::string(this->toplevel);
 
       localToplevel += "/" + comp.first;
       packageFileName +=
@@ -247,10 +247,10 @@ int cmCPackArchiveGenerator::PackageComponents(bool ignoreGroup)
       {
         DECLARE_AND_OPEN_ARCHIVE(packageFileName, archive);
         // Add the files of this component to the archive
-        addOneComponentToArchive(archive, &(comp.second));
+        this->addOneComponentToArchive(archive, &(comp.second));
       }
       // add the generated package to package file names list
-      packageFileNames.push_back(std::move(packageFileName));
+      this->packageFileNames.push_back(std::move(packageFileName));
     }
   }
   return 1;
@@ -259,17 +259,17 @@ int cmCPackArchiveGenerator::PackageComponents(bool ignoreGroup)
 int cmCPackArchiveGenerator::PackageComponentsAllInOne()
 {
   // reset the package file names
-  packageFileNames.clear();
-  packageFileNames.emplace_back(toplevel);
-  packageFileNames[0] += "/";
+  this->packageFileNames.clear();
+  this->packageFileNames.emplace_back(this->toplevel);
+  this->packageFileNames[0] += "/";
 
   if (this->IsSet("CPACK_ARCHIVE_FILE_NAME")) {
-    packageFileNames[0] += this->GetOption("CPACK_ARCHIVE_FILE_NAME");
+    this->packageFileNames[0] += this->GetOption("CPACK_ARCHIVE_FILE_NAME");
   } else {
-    packageFileNames[0] += this->GetOption("CPACK_PACKAGE_FILE_NAME");
+    this->packageFileNames[0] += this->GetOption("CPACK_PACKAGE_FILE_NAME");
   }
 
-  packageFileNames[0] += this->GetOutputExtension();
+  this->packageFileNames[0] += this->GetOutputExtension();
 
   cmCPackLogger(cmCPackLog::LOG_VERBOSE,
                 "Packaging all groups in one package..."
@@ -280,7 +280,7 @@ int cmCPackArchiveGenerator::PackageComponentsAllInOne()
   // The ALL COMPONENTS in ONE package case
   for (auto& comp : this->Components) {
     // Add the files of this component to the archive
-    addOneComponentToArchive(archive, &(comp.second));
+    this->addOneComponentToArchive(archive, &(comp.second));
   }
 
   // archive goes out of scope so it will finalized and closed.
@@ -289,41 +289,42 @@ int cmCPackArchiveGenerator::PackageComponentsAllInOne()
 
 int cmCPackArchiveGenerator::PackageFiles()
 {
-  cmCPackLogger(cmCPackLog::LOG_DEBUG, "Toplevel: " << toplevel << std::endl);
+  cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                "Toplevel: " << this->toplevel << std::endl);
 
-  if (WantsComponentInstallation()) {
+  if (this->WantsComponentInstallation()) {
     // CASE 1 : COMPONENT ALL-IN-ONE package
     // If ALL COMPONENTS in ONE package has been requested
     // then the package file is unique and should be open here.
-    if (componentPackageMethod == ONE_PACKAGE) {
-      return PackageComponentsAllInOne();
+    if (this->componentPackageMethod == ONE_PACKAGE) {
+      return this->PackageComponentsAllInOne();
     }
     // CASE 2 : COMPONENT CLASSICAL package(s) (i.e. not all-in-one)
     // There will be 1 package for each component group
     // however one may require to ignore component group and
     // in this case you'll get 1 package for each component.
-    return PackageComponents(componentPackageMethod ==
-                             ONE_PACKAGE_PER_COMPONENT);
+    return this->PackageComponents(this->componentPackageMethod ==
+                                   ONE_PACKAGE_PER_COMPONENT);
   }
 
   // CASE 3 : NON COMPONENT package.
   DECLARE_AND_OPEN_ARCHIVE(packageFileNames[0], archive);
-  cmWorkingDirectory workdir(toplevel);
+  cmWorkingDirectory workdir(this->toplevel);
   if (workdir.Failed()) {
     cmCPackLogger(cmCPackLog::LOG_ERROR,
                   "Failed to change working directory to "
-                    << toplevel << " : "
+                    << this->toplevel << " : "
                     << std::strerror(workdir.GetLastResult()) << std::endl);
     return 0;
   }
-  for (std::string const& file : files) {
+  for (std::string const& file : this->files) {
     // Get the relative path to the file
-    std::string rp = cmSystemTools::RelativePath(toplevel, file);
+    std::string rp = cmSystemTools::RelativePath(this->toplevel, file);
     archive.Add(rp, 0, nullptr, false);
     if (!archive) {
       cmCPackLogger(cmCPackLog::LOG_ERROR,
                     "Problem while adding file <"
-                      << file << "> to archive <" << packageFileNames[0]
+                      << file << "> to archive <" << this->packageFileNames[0]
                       << ">, ERROR = " << archive.GetError() << std::endl);
       return 0;
     }
@@ -342,7 +343,7 @@ bool cmCPackArchiveGenerator::SupportsComponentInstallation() const
   // The Component installation support should only
   // be activated if explicitly requested by the user
   // (for backward compatibility reason)
-  return IsOn("CPACK_ARCHIVE_COMPONENT_INSTALL");
+  return this->IsOn("CPACK_ARCHIVE_COMPONENT_INSTALL");
 }
 
 bool cmCPackArchiveGenerator::SetArchiveOptions(cmArchiveWrite* archive)
diff --git a/Source/CPack/cmCPackComponentGroup.cxx b/Source/CPack/cmCPackComponentGroup.cxx
index d40e5fcf84..4305c7eb2d 100644
--- a/Source/CPack/cmCPackComponentGroup.cxx
+++ b/Source/CPack/cmCPackComponentGroup.cxx
@@ -25,6 +25,6 @@ unsigned long cmCPackComponent::GetInstalledSize(
 unsigned long cmCPackComponent::GetInstalledSizeInKbytes(
   const std::string& installDir) const
 {
-  unsigned long result = (GetInstalledSize(installDir) + 512) / 1024;
+  unsigned long result = (this->GetInstalledSize(installDir) + 512) / 1024;
   return result ? result : 1;
 }
diff --git a/Source/CPack/cmCPackDebGenerator.cxx b/Source/CPack/cmCPackDebGenerator.cxx
index 6f21d8756e..43dbdb5717 100644
--- a/Source/CPack/cmCPackDebGenerator.cxx
+++ b/Source/CPack/cmCPackDebGenerator.cxx
@@ -96,20 +96,20 @@ DebGenerator::DebGenerator(
   }
 
   if (!strcmp(debianCompressionType, "lzma")) {
-    CompressionSuffix = ".lzma";
-    TarCompressionType = cmArchiveWrite::CompressLZMA;
+    this->CompressionSuffix = ".lzma";
+    this->TarCompressionType = cmArchiveWrite::CompressLZMA;
   } else if (!strcmp(debianCompressionType, "xz")) {
-    CompressionSuffix = ".xz";
-    TarCompressionType = cmArchiveWrite::CompressXZ;
+    this->CompressionSuffix = ".xz";
+    this->TarCompressionType = cmArchiveWrite::CompressXZ;
   } else if (!strcmp(debianCompressionType, "bzip2")) {
-    CompressionSuffix = ".bz2";
-    TarCompressionType = cmArchiveWrite::CompressBZip2;
+    this->CompressionSuffix = ".bz2";
+    this->TarCompressionType = cmArchiveWrite::CompressBZip2;
   } else if (!strcmp(debianCompressionType, "gzip")) {
-    CompressionSuffix = ".gz";
-    TarCompressionType = cmArchiveWrite::CompressGZip;
+    this->CompressionSuffix = ".gz";
+    this->TarCompressionType = cmArchiveWrite::CompressGZip;
   } else if (!strcmp(debianCompressionType, "none")) {
-    CompressionSuffix.clear();
-    TarCompressionType = cmArchiveWrite::CompressNone;
+    this->CompressionSuffix.clear();
+    this->TarCompressionType = cmArchiveWrite::CompressNone;
   } else {
     cmCPackLogger(cmCPackLog::LOG_ERROR,
                   "Error unrecognized compression type: "
@@ -119,22 +119,22 @@ DebGenerator::DebGenerator(
 
 bool DebGenerator::generate() const
 {
-  generateDebianBinaryFile();
-  generateControlFile();
-  if (!generateDataTar()) {
+  this->generateDebianBinaryFile();
+  this->generateControlFile();
+  if (!this->generateDataTar()) {
     return false;
   }
-  std::string md5Filename = generateMD5File();
-  if (!generateControlTar(md5Filename)) {
+  std::string md5Filename = this->generateMD5File();
+  if (!this->generateControlTar(md5Filename)) {
     return false;
   }
-  return generateDeb();
+  return this->generateDeb();
 }
 
 void DebGenerator::generateDebianBinaryFile() const
 {
   // debian-binary file
-  const std::string dbfilename = WorkDir + "/debian-binary";
+  const std::string dbfilename = this->WorkDir + "/debian-binary";
   cmGeneratedFileStream out;
   out.Open(dbfilename, false, true);
   out << "2.0\n"; // required for valid debian package
@@ -142,18 +142,18 @@ void DebGenerator::generateDebianBinaryFile() const
 
 void DebGenerator::generateControlFile() const
 {
-  std::string ctlfilename = WorkDir + "/control";
+  std::string ctlfilename = this->WorkDir + "/control";
 
   cmGeneratedFileStream out;
   out.Open(ctlfilename, false, true);
-  for (auto const& kv : ControlValues) {
+  for (auto const& kv : this->ControlValues) {
     out << kv.first << ": " << kv.second << "\n";
   }
 
   unsigned long totalSize = 0;
   {
-    std::string dirName = cmStrCat(TemporaryDir, '/');
-    for (std::string const& file : PackageFiles) {
+    std::string dirName = cmStrCat(this->TemporaryDir, '/');
+    for (std::string const& file : this->PackageFiles) {
       totalSize += cmSystemTools::FileLength(file);
     }
   }
@@ -162,7 +162,8 @@ void DebGenerator::generateControlFile() const
 
 bool DebGenerator::generateDataTar() const
 {
-  std::string filename_data_tar = WorkDir + "/data.tar" + CompressionSuffix;
+  std::string filename_data_tar =
+    this->WorkDir + "/data.tar" + this->CompressionSuffix;
   cmGeneratedFileStream fileStream_data_tar;
   fileStream_data_tar.Open(filename_data_tar, false, true);
   if (!fileStream_data_tar) {
@@ -171,8 +172,8 @@ bool DebGenerator::generateDataTar() const
                     << filename_data_tar << "\" for writing" << std::endl);
     return false;
   }
-  cmArchiveWrite data_tar(fileStream_data_tar, TarCompressionType,
-                          DebianArchiveType);
+  cmArchiveWrite data_tar(fileStream_data_tar, this->TarCompressionType,
+                          this->DebianArchiveType);
   data_tar.Open();
 
   // uid/gid should be the one of the root user, and this root user has
@@ -184,16 +185,16 @@ bool DebGenerator::generateDataTar() const
   // collect all top level install dirs for that
   // e.g. /opt/bin/foo, /usr/bin/bar and /usr/bin/baz would
   // give /usr and /opt
-  size_t topLevelLength = WorkDir.length();
+  size_t topLevelLength = this->WorkDir.length();
   cmCPackLogger(cmCPackLog::LOG_DEBUG,
-                "WDIR: \"" << WorkDir << "\", length = " << topLevelLength
-                           << std::endl);
+                "WDIR: \"" << this->WorkDir
+                           << "\", length = " << topLevelLength << std::endl);
   std::set<std::string> orderedFiles;
 
   // we have to reconstruct the parent folders as well
 
-  for (std::string currentPath : PackageFiles) {
-    while (currentPath != WorkDir) {
+  for (std::string currentPath : this->PackageFiles) {
+    while (currentPath != this->WorkDir) {
       // the last one IS WorkDir, but we do not want this one:
       // XXX/application/usr/bin/myprogram with GEN_WDIR=XXX/application
       // should not add XXX/application
@@ -235,7 +236,7 @@ bool DebGenerator::generateDataTar() const
       cmCPackLogger(cmCPackLog::LOG_ERROR,
                     "Problem adding file to tar:"
                       << std::endl
-                      << "#top level directory: " << WorkDir << std::endl
+                      << "#top level directory: " << this->WorkDir << std::endl
                       << "#file: " << file << std::endl
                       << "#error:" << data_tar.GetError() << std::endl);
       return false;
@@ -246,13 +247,13 @@ bool DebGenerator::generateDataTar() const
 
 std::string DebGenerator::generateMD5File() const
 {
-  std::string md5filename = WorkDir + "/md5sums";
+  std::string md5filename = this->WorkDir + "/md5sums";
 
   cmGeneratedFileStream out;
   out.Open(md5filename, false, true);
 
-  std::string topLevelWithTrailingSlash = cmStrCat(TemporaryDir, '/');
-  for (std::string const& file : PackageFiles) {
+  std::string topLevelWithTrailingSlash = cmStrCat(this->TemporaryDir, '/');
+  for (std::string const& file : this->PackageFiles) {
     // hash only regular files
     if (cmSystemTools::FileIsDirectory(file) ||
         cmSystemTools::FileIsSymlink(file)) {
@@ -281,7 +282,7 @@ std::string DebGenerator::generateMD5File() const
 
 bool DebGenerator::generateControlTar(std::string const& md5Filename) const
 {
-  std::string filename_control_tar = WorkDir + "/control.tar.gz";
+  std::string filename_control_tar = this->WorkDir + "/control.tar.gz";
 
   cmGeneratedFileStream fileStream_control_tar;
   fileStream_control_tar.Open(filename_control_tar, false, true);
@@ -292,7 +293,8 @@ bool DebGenerator::generateControlTar(std::string const& md5Filename) const
     return false;
   }
   cmArchiveWrite control_tar(fileStream_control_tar,
-                             cmArchiveWrite::CompressGZip, DebianArchiveType);
+                             cmArchiveWrite::CompressGZip,
+                             this->DebianArchiveType);
   control_tar.Open();
 
   // sets permissions and uid/gid for the files
@@ -314,24 +316,25 @@ bool DebGenerator::generateControlTar(std::string const& md5Filename) const
   control_tar.SetPermissions(permission644);
 
   // adds control and md5sums
-  if (!control_tar.Add(md5Filename, WorkDir.length(), ".") ||
-      !control_tar.Add(WorkDir + "/control", WorkDir.length(), ".")) {
+  if (!control_tar.Add(md5Filename, this->WorkDir.length(), ".") ||
+      !control_tar.Add(this->WorkDir + "/control", this->WorkDir.length(),
+                       ".")) {
     cmCPackLogger(cmCPackLog::LOG_ERROR,
                   "Error adding file to tar:"
                     << std::endl
-                    << "#top level directory: " << WorkDir << std::endl
+                    << "#top level directory: " << this->WorkDir << std::endl
                     << "#file: \"control\" or \"md5sums\"" << std::endl
                     << "#error:" << control_tar.GetError() << std::endl);
     return false;
   }
 
   // adds generated shlibs file
-  if (GenShLibs) {
-    if (!control_tar.Add(ShLibsFilename, WorkDir.length(), ".")) {
+  if (this->GenShLibs) {
+    if (!control_tar.Add(this->ShLibsFilename, this->WorkDir.length(), ".")) {
       cmCPackLogger(cmCPackLog::LOG_ERROR,
                     "Error adding file to tar:"
                       << std::endl
-                      << "#top level directory: " << WorkDir << std::endl
+                      << "#top level directory: " << this->WorkDir << std::endl
                       << "#file: \"shlibs\"" << std::endl
                       << "#error:" << control_tar.GetError() << std::endl);
       return false;
@@ -339,13 +342,13 @@ bool DebGenerator::generateControlTar(std::string const& md5Filename) const
   }
 
   // adds LDCONFIG related files
-  if (GenPostInst) {
+  if (this->GenPostInst) {
     control_tar.SetPermissions(permission755);
-    if (!control_tar.Add(PostInst, WorkDir.length(), ".")) {
+    if (!control_tar.Add(this->PostInst, this->WorkDir.length(), ".")) {
       cmCPackLogger(cmCPackLog::LOG_ERROR,
                     "Error adding file to tar:"
                       << std::endl
-                      << "#top level directory: " << WorkDir << std::endl
+                      << "#top level directory: " << this->WorkDir << std::endl
                       << "#file: \"postinst\"" << std::endl
                       << "#error:" << control_tar.GetError() << std::endl);
       return false;
@@ -353,13 +356,13 @@ bool DebGenerator::generateControlTar(std::string const& md5Filename) const
     control_tar.SetPermissions(permission644);
   }
 
-  if (GenPostRm) {
+  if (this->GenPostRm) {
     control_tar.SetPermissions(permission755);
-    if (!control_tar.Add(PostRm, WorkDir.length(), ".")) {
+    if (!control_tar.Add(this->PostRm, this->WorkDir.length(), ".")) {
       cmCPackLogger(cmCPackLog::LOG_ERROR,
                     "Error adding file to tar:"
                       << std::endl
-                      << "#top level directory: " << WorkDir << std::endl
+                      << "#top level directory: " << this->WorkDir << std::endl
                       << "#file: \"postinst\"" << std::endl
                       << "#error:" << control_tar.GetError() << std::endl);
       return false;
@@ -370,7 +373,7 @@ bool DebGenerator::generateControlTar(std::string const& md5Filename) const
   // for the other files, we use
   // -either the original permission on the files
   // -either a permission strictly defined by the Debian policies
-  if (ControlExtra) {
+  if (this->ControlExtra) {
     // permissions are now controlled by the original file permissions
 
     static const char* strictFiles[] = { "config", "postinst", "postrm",
@@ -381,19 +384,20 @@ bool DebGenerator::generateControlTar(std::string const& md5Filename) const
     // default
     control_tar.ClearPermissions();
 
-    std::vector<std::string> controlExtraList = cmExpandedList(ControlExtra);
+    std::vector<std::string> controlExtraList =
+      cmExpandedList(this->ControlExtra);
     for (std::string const& i : controlExtraList) {
       std::string filenamename = cmsys::SystemTools::GetFilenameName(i);
-      std::string localcopy = WorkDir + "/" + filenamename;
+      std::string localcopy = this->WorkDir + "/" + filenamename;
 
-      if (PermissionStrictPolicy) {
+      if (this->PermissionStrictPolicy) {
         control_tar.SetPermissions(
           setStrictFiles.count(filenamename) ? permission755 : permission644);
       }
 
       // if we can copy the file, it means it does exist, let's add it:
       if (cmsys::SystemTools::CopyFileIfDifferent(i, localcopy)) {
-        control_tar.Add(localcopy, WorkDir.length(), ".");
+        control_tar.Add(localcopy, this->WorkDir.length(), ".");
       }
     }
   }
@@ -408,8 +412,8 @@ bool DebGenerator::generateDeb() const
   // difference is that debian uses the BSD ar style archive whereas most
   // Linux distro have a GNU ar.
   // See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=161593 for more info
-  std::string const outputPath = TopLevelDir + "/" + OutputName;
-  std::string const tlDir = WorkDir + "/";
+  std::string const outputPath = this->TopLevelDir + "/" + this->OutputName;
+  std::string const tlDir = this->WorkDir + "/";
   cmGeneratedFileStream debStream;
   debStream.Open(outputPath, false, true);
   cmArchiveWrite deb(debStream, cmArchiveWrite::CompressNone, "arbsd");
@@ -422,12 +426,13 @@ bool DebGenerator::generateDeb() const
 
   if (!deb.Add(tlDir + "debian-binary", tlDir.length()) ||
       !deb.Add(tlDir + "control.tar.gz", tlDir.length()) ||
-      !deb.Add(tlDir + "data.tar" + CompressionSuffix, tlDir.length())) {
+      !deb.Add(tlDir + "data.tar" + this->CompressionSuffix, tlDir.length())) {
     cmCPackLogger(cmCPackLog::LOG_ERROR,
                   "Error creating debian package:"
                     << std::endl
-                    << "#top level directory: " << TopLevelDir << std::endl
-                    << "#file: " << OutputName << std::endl
+                    << "#top level directory: " << this->TopLevelDir
+                    << std::endl
+                    << "#file: " << this->OutputName << std::endl
                     << "#error:" << deb.GetError() << std::endl);
     return false;
   }
@@ -455,7 +460,8 @@ int cmCPackDebGenerator::PackageOnePack(std::string const& initialTopLevel,
   int retval = 1;
   // Begin the archive for this pack
   std::string localToplevel(initialTopLevel);
-  std::string packageFileName(cmSystemTools::GetParentDirectory(toplevel));
+  std::string packageFileName(
+    cmSystemTools::GetParentDirectory(this->toplevel));
   std::string outputFileName(
     std::string(this->GetOption("CPACK_PACKAGE_FILE_NAME")) + "-" +
     packageName + this->GetOutputExtension());
@@ -495,17 +501,17 @@ int cmCPackDebGenerator::PackageOnePack(std::string const& initialTopLevel,
                       << std::endl);
       return 0;
     }
-    packageFiles = gl.GetFiles();
+    this->packageFiles = gl.GetFiles();
   }
 
-  int res = createDeb();
+  int res = this->createDeb();
   if (res != 1) {
     retval = 0;
   }
   // add the generated package to package file names list
   packageFileName = cmStrCat(this->GetOption("CPACK_TOPLEVEL_DIRECTORY"), '/',
                              this->GetOption("GEN_CPACK_OUTPUT_FILE_NAME"));
-  packageFileNames.push_back(std::move(packageFileName));
+  this->packageFileNames.push_back(std::move(packageFileName));
 
   if (this->IsOn("GEN_CPACK_DEBIAN_DEBUGINFO_PACKAGE") &&
       this->GetOption("GEN_DBGSYMDIR")) {
@@ -521,9 +527,9 @@ int cmCPackDebGenerator::PackageOnePack(std::string const& initialTopLevel,
                       << std::endl);
       return 0;
     }
-    packageFiles = gl.GetFiles();
+    this->packageFiles = gl.GetFiles();
 
-    res = createDbgsymDDeb();
+    res = this->createDbgsymDDeb();
     if (res != 1) {
       retval = 0;
     }
@@ -531,7 +537,7 @@ int cmCPackDebGenerator::PackageOnePack(std::string const& initialTopLevel,
     packageFileName =
       cmStrCat(this->GetOption("CPACK_TOPLEVEL_DIRECTORY"), '/',
                this->GetOption("GEN_CPACK_DBGSYM_OUTPUT_FILE_NAME"));
-    packageFileNames.push_back(std::move(packageFileName));
+    this->packageFileNames.push_back(std::move(packageFileName));
   }
 
   return retval;
@@ -542,7 +548,7 @@ int cmCPackDebGenerator::PackageComponents(bool ignoreGroup)
   int retval = 1;
   /* Reset package file name list it will be populated during the
    * component packaging run*/
-  packageFileNames.clear();
+  this->packageFileNames.clear();
   std::string initialTopLevel(this->GetOption("CPACK_TEMPORARY_DIRECTORY"));
 
   // The default behavior is to have one package by component group
@@ -552,7 +558,7 @@ int cmCPackDebGenerator::PackageComponents(bool ignoreGroup)
       cmCPackLogger(cmCPackLog::LOG_VERBOSE,
                     "Packaging component group: " << compG.first << std::endl);
       // Begin the archive for this group
-      retval &= PackageOnePack(initialTopLevel, compG.first);
+      retval &= this->PackageOnePack(initialTopLevel, compG.first);
     }
     // Handle Orphan components (components not belonging to any groups)
     for (auto const& comp : this->Components) {
@@ -565,7 +571,7 @@ int cmCPackDebGenerator::PackageComponents(bool ignoreGroup)
             << "> does not belong to any group, package it separately."
             << std::endl);
         // Begin the archive for this orphan component
-        retval &= PackageOnePack(initialTopLevel, comp.first);
+        retval &= this->PackageOnePack(initialTopLevel, comp.first);
       }
     }
   }
@@ -573,7 +579,7 @@ int cmCPackDebGenerator::PackageComponents(bool ignoreGroup)
   // We build 1 package per component
   else {
     for (auto const& comp : this->Components) {
-      retval &= PackageOnePack(initialTopLevel, comp.first);
+      retval &= this->PackageOnePack(initialTopLevel, comp.first);
     }
   }
   return retval;
@@ -586,7 +592,7 @@ int cmCPackDebGenerator::PackageComponentsAllInOne(
   int retval = 1;
   /* Reset package file name list it will be populated during the
    * component packaging run*/
-  packageFileNames.clear();
+  this->packageFileNames.clear();
   std::string initialTopLevel(this->GetOption("CPACK_TEMPORARY_DIRECTORY"));
 
   cmCPackLogger(cmCPackLog::LOG_VERBOSE,
@@ -596,7 +602,8 @@ int cmCPackDebGenerator::PackageComponentsAllInOne(
 
   // The ALL GROUPS in ONE package case
   std::string localToplevel(initialTopLevel);
-  std::string packageFileName(cmSystemTools::GetParentDirectory(toplevel));
+  std::string packageFileName(
+    cmSystemTools::GetParentDirectory(this->toplevel));
   std::string outputFileName(
     std::string(this->GetOption("CPACK_PACKAGE_FILE_NAME")) +
     this->GetOutputExtension());
@@ -641,38 +648,38 @@ int cmCPackDebGenerator::PackageComponentsAllInOne(
                     << std::endl);
     return 0;
   }
-  packageFiles = gl.GetFiles();
+  this->packageFiles = gl.GetFiles();
 
-  int res = createDeb();
+  int res = this->createDeb();
   if (res != 1) {
     retval = 0;
   }
   // add the generated package to package file names list
   packageFileName = cmStrCat(this->GetOption("CPACK_TOPLEVEL_DIRECTORY"), '/',
                              this->GetOption("GEN_CPACK_OUTPUT_FILE_NAME"));
-  packageFileNames.push_back(std::move(packageFileName));
+  this->packageFileNames.push_back(std::move(packageFileName));
   return retval;
 }
 
 int cmCPackDebGenerator::PackageFiles()
 {
   /* Are we in the component packaging case */
-  if (WantsComponentInstallation()) {
+  if (this->WantsComponentInstallation()) {
     // CASE 1 : COMPONENT ALL-IN-ONE package
     // If ALL GROUPS or ALL COMPONENTS in ONE package has been requested
     // then the package file is unique and should be open here.
-    if (componentPackageMethod == ONE_PACKAGE) {
-      return PackageComponentsAllInOne("ALL_COMPONENTS_IN_ONE");
+    if (this->componentPackageMethod == ONE_PACKAGE) {
+      return this->PackageComponentsAllInOne("ALL_COMPONENTS_IN_ONE");
     }
     // CASE 2 : COMPONENT CLASSICAL package(s) (i.e. not all-in-one)
     // There will be 1 package for each component group
     // however one may require to ignore component group and
     // in this case you'll get 1 package for each component.
-    return PackageComponents(componentPackageMethod ==
-                             ONE_PACKAGE_PER_COMPONENT);
+    return this->PackageComponents(this->componentPackageMethod ==
+                                   ONE_PACKAGE_PER_COMPONENT);
   }
   // CASE 3 : NON COMPONENT package.
-  return PackageComponentsAllInOne("");
+  return this->PackageComponentsAllInOne("");
 }
 
 int cmCPackDebGenerator::createDeb()
@@ -787,7 +794,7 @@ int cmCPackDebGenerator::createDeb()
   }
 
   DebGenerator gen(
-    Logger, this->GetOption("GEN_CPACK_OUTPUT_FILE_NAME"), strGenWDIR,
+    this->Logger, this->GetOption("GEN_CPACK_OUTPUT_FILE_NAME"), strGenWDIR,
     this->GetOption("CPACK_TOPLEVEL_DIRECTORY"),
     this->GetOption("CPACK_TEMPORARY_DIRECTORY"),
     this->GetOption("GEN_CPACK_DEBIAN_COMPRESSION_TYPE"),
@@ -796,7 +803,7 @@ int cmCPackDebGenerator::createDeb()
     this->IsOn("GEN_CPACK_DEBIAN_GENERATE_POSTRM"), postrm,
     this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA"),
     this->IsSet("GEN_CPACK_DEBIAN_PACKAGE_CONTROL_STRICT_PERMISSION"),
-    packageFiles);
+    this->packageFiles);
 
   if (!gen.generate()) {
     return 0;
@@ -842,7 +849,7 @@ int cmCPackDebGenerator::createDbgsymDDeb()
   }
 
   DebGenerator gen(
-    Logger, this->GetOption("GEN_CPACK_DBGSYM_OUTPUT_FILE_NAME"),
+    this->Logger, this->GetOption("GEN_CPACK_DBGSYM_OUTPUT_FILE_NAME"),
     this->GetOption("GEN_DBGSYMDIR"),
 
     this->GetOption("CPACK_TOPLEVEL_DIRECTORY"),
@@ -851,7 +858,7 @@ int cmCPackDebGenerator::createDbgsymDDeb()
     this->GetOption("GEN_CPACK_DEBIAN_ARCHIVE_TYPE"), controlValues, false, "",
     false, "", false, "", nullptr,
     this->IsSet("GEN_CPACK_DEBIAN_PACKAGE_CONTROL_STRICT_PERMISSION"),
-    packageFiles);
+    this->packageFiles);
 
   if (!gen.generate()) {
     return 0;
@@ -861,25 +868,25 @@ int cmCPackDebGenerator::createDbgsymDDeb()
 
 bool cmCPackDebGenerator::SupportsComponentInstallation() const
 {
-  return IsOn("CPACK_DEB_COMPONENT_INSTALL");
+  return this->IsOn("CPACK_DEB_COMPONENT_INSTALL");
 }
 
 std::string cmCPackDebGenerator::GetComponentInstallDirNameSuffix(
   const std::string& componentName)
 {
-  if (componentPackageMethod == ONE_PACKAGE_PER_COMPONENT) {
+  if (this->componentPackageMethod == ONE_PACKAGE_PER_COMPONENT) {
     return componentName;
   }
 
-  if (componentPackageMethod == ONE_PACKAGE) {
+  if (this->componentPackageMethod == ONE_PACKAGE) {
     return std::string("ALL_COMPONENTS_IN_ONE");
   }
   // We have to find the name of the COMPONENT GROUP
   // the current COMPONENT belongs to.
   std::string groupVar =
     "CPACK_COMPONENT_" + cmSystemTools::UpperCase(componentName) + "_GROUP";
-  if (nullptr != GetOption(groupVar)) {
-    return std::string(GetOption(groupVar));
+  if (nullptr != this->GetOption(groupVar)) {
+    return std::string(this->GetOption(groupVar));
   }
   return componentName;
 }
diff --git a/Source/CPack/cmCPackExternalGenerator.cxx b/Source/CPack/cmCPackExternalGenerator.cxx
index 0bc8456710..e3521a0e5a 100644
--- a/Source/CPack/cmCPackExternalGenerator.cxx
+++ b/Source/CPack/cmCPackExternalGenerator.cxx
@@ -95,7 +95,7 @@ int cmCPackExternalGenerator::InstallProjectViaInstallCommands(
   bool setDestDir, const std::string& tempInstallDirectory)
 {
   if (this->StagingEnabled()) {
-    return cmCPackGenerator::InstallProjectViaInstallCommands(
+    return this->cmCPackGenerator::InstallProjectViaInstallCommands(
       setDestDir, tempInstallDirectory);
   }
 
@@ -106,7 +106,7 @@ int cmCPackExternalGenerator::InstallProjectViaInstallScript(
   bool setDestDir, const std::string& tempInstallDirectory)
 {
   if (this->StagingEnabled()) {
-    return cmCPackGenerator::InstallProjectViaInstallScript(
+    return this->cmCPackGenerator::InstallProjectViaInstallScript(
       setDestDir, tempInstallDirectory);
   }
 
@@ -118,7 +118,7 @@ int cmCPackExternalGenerator::InstallProjectViaInstalledDirectories(
   const mode_t* default_dir_mode)
 {
   if (this->StagingEnabled()) {
-    return cmCPackGenerator::InstallProjectViaInstalledDirectories(
+    return this->cmCPackGenerator::InstallProjectViaInstalledDirectories(
       setDestDir, tempInstallDirectory, default_dir_mode);
   }
 
@@ -130,7 +130,7 @@ int cmCPackExternalGenerator::RunPreinstallTarget(
   cmGlobalGenerator* globalGenerator, const std::string& buildConfig)
 {
   if (this->StagingEnabled()) {
-    return cmCPackGenerator::RunPreinstallTarget(
+    return this->cmCPackGenerator::RunPreinstallTarget(
       installProjectName, installDirectory, globalGenerator, buildConfig);
   }
 
@@ -145,7 +145,7 @@ int cmCPackExternalGenerator::InstallCMakeProject(
   std::string& absoluteDestFiles)
 {
   if (this->StagingEnabled()) {
-    return cmCPackGenerator::InstallCMakeProject(
+    return this->cmCPackGenerator::InstallCMakeProject(
       setDestDir, installDirectory, baseTempInstallDirectory, default_dir_mode,
       component, componentInstall, installSubDirectory, buildConfig,
       absoluteDestFiles);
diff --git a/Source/CPack/cmCPackGenerator.cxx b/Source/CPack/cmCPackGenerator.cxx
index 8b544b4522..3db4162c92 100644
--- a/Source/CPack/cmCPackGenerator.cxx
+++ b/Source/CPack/cmCPackGenerator.cxx
@@ -60,18 +60,18 @@ int cmCPackGenerator::PrepareNames()
   cmCPackLogger(cmCPackLog::LOG_DEBUG, "Create temp directory." << std::endl);
 
   // checks CPACK_SET_DESTDIR support
-  if (IsOn("CPACK_SET_DESTDIR")) {
-    if (SETDESTDIR_UNSUPPORTED == SupportsSetDestdir()) {
+  if (this->IsOn("CPACK_SET_DESTDIR")) {
+    if (SETDESTDIR_UNSUPPORTED == this->SupportsSetDestdir()) {
       cmCPackLogger(cmCPackLog::LOG_ERROR,
                     "CPACK_SET_DESTDIR is set to ON but the '"
-                      << Name << "' generator does NOT support it."
+                      << this->Name << "' generator does NOT support it."
                       << std::endl);
       return 0;
     }
-    if (SETDESTDIR_SHOULD_NOT_BE_USED == SupportsSetDestdir()) {
+    if (SETDESTDIR_SHOULD_NOT_BE_USED == this->SupportsSetDestdir()) {
       cmCPackLogger(cmCPackLog::LOG_WARNING,
                     "CPACK_SET_DESTDIR is set to ON but it is "
-                      << "usually a bad idea to do that with '" << Name
+                      << "usually a bad idea to do that with '" << this->Name
                       << "' generator. Use at your own risk." << std::endl);
     }
   }
@@ -380,8 +380,8 @@ int cmCPackGenerator::InstallProjectViaInstalledDirectories(
                         << std::endl);
         return 0;
       }
-      files = gl.GetFiles();
-      for (std::string const& gf : files) {
+      this->files = gl.GetFiles();
+      for (std::string const& gf : this->files) {
         bool skip = false;
         std::string inFile = gf;
         if (cmSystemTools::FileIsDirectory(gf)) {
@@ -763,7 +763,7 @@ int cmCPackGenerator::InstallCMakeProject(
     //  one install directory for each component **GROUP**
     // instead of the default
     //  one install directory for each component.
-    tempInstallDirectory += GetComponentInstallDirNameSuffix(component);
+    tempInstallDirectory += this->GetComponentInstallDirNameSuffix(component);
     if (this->IsOn("CPACK_COMPONENT_INCLUDE_TOPLEVEL_DIRECTORY")) {
       tempInstallDirectory += "/";
       tempInstallDirectory += this->GetOption("CPACK_PACKAGE_FILE_NAME");
@@ -897,7 +897,7 @@ int cmCPackGenerator::InstallCMakeProject(
   // ABSOLUTE INSTALL DESTINATION or CPack has been asked for
   // then ask cmake_install.cmake script to error out
   // as soon as it occurs (before installing file)
-  if (!SupportsAbsoluteDestination() ||
+  if (!this->SupportsAbsoluteDestination() ||
       this->IsOn("CPACK_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION")) {
     mf.AddDefinition("CMAKE_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION", "1");
   }
@@ -933,7 +933,7 @@ int cmCPackGenerator::InstallCMakeProject(
       localFileName = cmSystemTools::RelativePath(InstallPrefix, *fit);
       localFileName =
         localFileName.substr(localFileName.find_first_not_of('/'));
-      Components[component].Files.push_back(localFileName);
+      this->Components[component].Files.push_back(localFileName);
       cmCPackLogger(cmCPackLog::LOG_DEBUG,
                     "Adding file <" << localFileName << "> to component <"
                                     << component << ">" << std::endl);
@@ -952,7 +952,7 @@ int cmCPackGenerator::InstallCMakeProject(
     if (componentInstall) {
       std::string absoluteDestFileComponent =
         std::string("CPACK_ABSOLUTE_DESTINATION_FILES") + "_" +
-        GetComponentInstallDirNameSuffix(component);
+        this->GetComponentInstallDirNameSuffix(component);
       if (nullptr != this->GetOption(absoluteDestFileComponent)) {
         std::string absoluteDestFilesListComponent =
           cmStrCat(this->GetOption(absoluteDestFileComponent), ';', *d);
@@ -1073,17 +1073,17 @@ int cmCPackGenerator::DoPackage()
   }
 
   // The files to be installed
-  files = gl.GetFiles();
+  this->files = gl.GetFiles();
 
-  packageFileNames.clear();
+  this->packageFileNames.clear();
   /* Put at least one file name into the list of
    * wanted packageFileNames. The specific generator
    * may update this during PackageFiles.
    * (either putting several names or updating the provided one)
    */
-  packageFileNames.emplace_back(tempPackageFileName ? tempPackageFileName
-                                                    : "");
-  toplevel = tempDirectory;
+  this->packageFileNames.emplace_back(tempPackageFileName ? tempPackageFileName
+                                                          : "");
+  this->toplevel = tempDirectory;
   { // scope that enables package generators to run internal scripts with
     // latest CMake policies enabled
     cmMakefile::ScopePushPop pp{ this->MakefileMap };
@@ -1127,10 +1127,10 @@ int cmCPackGenerator::DoPackage()
    *    (because the specific generator did 'normalize' it)
    */
   cmCPackLogger(cmCPackLog::LOG_VERBOSE,
-                "Copying final package(s) [" << packageFileNames.size()
+                "Copying final package(s) [" << this->packageFileNames.size()
                                              << "]:" << std::endl);
   /* now copy package one by one */
-  for (std::string const& pkgFileName : packageFileNames) {
+  for (std::string const& pkgFileName : this->packageFileNames) {
     std::string tmpPF(this->GetOption("CPACK_OUTPUT_FILE_PREFIX"));
     std::string filename(cmSystemTools::GetFilenameName(pkgFileName));
     tempPackageFileName = pkgFileName.c_str();
@@ -1211,7 +1211,7 @@ bool cmCPackGenerator::IsSet(const std::string& name) const
 
 bool cmCPackGenerator::IsOn(const std::string& name) const
 {
-  return cmIsOn(GetOption(name));
+  return cmIsOn(this->GetOption(name));
 }
 
 bool cmCPackGenerator::IsSetToOff(const std::string& op) const
@@ -1405,7 +1405,7 @@ int cmCPackGenerator::PrepareGroupingKind()
   // fallback to default if not group based
   if (method == ONE_PACKAGE_PER_GROUP && this->ComponentGroups.empty() &&
       !this->Components.empty()) {
-    if (componentPackageMethod == ONE_PACKAGE) {
+    if (this->componentPackageMethod == ONE_PACKAGE) {
       method = ONE_PACKAGE;
     } else {
       method = ONE_PACKAGE_PER_COMPONENT;
@@ -1421,7 +1421,7 @@ int cmCPackGenerator::PrepareGroupingKind()
   // if user specified packaging method, override the default packaging
   // method
   if (method != UNKNOWN_COMPONENT_PACKAGE_METHOD) {
-    componentPackageMethod = method;
+    this->componentPackageMethod = method;
   }
 
   const char* method_names[] = { "ALL_COMPONENTS_IN_ONE", "IGNORE_GROUPS",
@@ -1430,7 +1430,8 @@ int cmCPackGenerator::PrepareGroupingKind()
   cmCPackLogger(cmCPackLog::LOG_VERBOSE,
                 "[" << this->Name << "]"
                     << " requested component grouping = "
-                    << method_names[componentPackageMethod] << std::endl);
+                    << method_names[this->componentPackageMethod]
+                    << std::endl);
 
   return 1;
 }
@@ -1451,13 +1452,14 @@ std::string cmCPackGenerator::GetComponentPackageFileName(
    */
   std::string suffix = "-" + groupOrComponentName;
   /* check if we should use DISPLAY name */
-  std::string dispNameVar = "CPACK_" + Name + "_USE_DISPLAY_NAME_IN_FILENAME";
-  if (IsOn(dispNameVar)) {
+  std::string dispNameVar =
+    "CPACK_" + this->Name + "_USE_DISPLAY_NAME_IN_FILENAME";
+  if (this->IsOn(dispNameVar)) {
     /* the component Group case */
     if (isGroupName) {
       std::string groupDispVar = "CPACK_COMPONENT_GROUP_" +
         cmSystemTools::UpperCase(groupOrComponentName) + "_DISPLAY_NAME";
-      const char* groupDispName = GetOption(groupDispVar);
+      const char* groupDispName = this->GetOption(groupDispVar);
       if (groupDispName) {
         suffix = "-" + std::string(groupDispName);
       }
@@ -1466,7 +1468,7 @@ std::string cmCPackGenerator::GetComponentPackageFileName(
     else {
       std::string dispVar = "CPACK_COMPONENT_" +
         cmSystemTools::UpperCase(groupOrComponentName) + "_DISPLAY_NAME";
-      const char* dispName = GetOption(dispVar);
+      const char* dispName = this->GetOption(dispVar);
       if (dispName) {
         suffix = "-" + std::string(dispName);
       }
@@ -1493,8 +1495,8 @@ bool cmCPackGenerator::SupportsComponentInstallation() const
 
 bool cmCPackGenerator::WantsComponentInstallation() const
 {
-  return (!IsOn("CPACK_MONOLITHIC_INSTALL") &&
-          SupportsComponentInstallation()
+  return (!this->IsOn("CPACK_MONOLITHIC_INSTALL") &&
+          this->SupportsComponentInstallation()
           // check that we have at least one group or component
           && (!this->ComponentGroups.empty() || !this->Components.empty()));
 }
@@ -1557,7 +1559,7 @@ cmCPackComponent* cmCPackGenerator::GetComponent(
 
     const char* groupName = this->GetOption(macroPrefix + "_GROUP");
     if (cmNonempty(groupName)) {
-      component->Group = GetComponentGroup(projectName, groupName);
+      component->Group = this->GetComponentGroup(projectName, groupName);
       component->Group->Components.push_back(component);
     } else {
       component->Group = nullptr;
@@ -1584,7 +1586,7 @@ cmCPackComponent* cmCPackGenerator::GetComponent(
     if (cmNonempty(depends)) {
       std::vector<std::string> dependsVector = cmExpandedList(depends);
       for (std::string const& depend : dependsVector) {
-        cmCPackComponent* child = GetComponent(projectName, depend);
+        cmCPackComponent* child = this->GetComponent(projectName, depend);
         component->Dependencies.push_back(child);
         child->ReverseDependencies.push_back(component);
       }
@@ -1620,7 +1622,8 @@ cmCPackComponentGroup* cmCPackGenerator::GetComponentGroup(
     const char* parentGroupName =
       this->GetOption(macroPrefix + "_PARENT_GROUP");
     if (cmNonempty(parentGroupName)) {
-      group->ParentGroup = GetComponentGroup(projectName, parentGroupName);
+      group->ParentGroup =
+        this->GetComponentGroup(projectName, parentGroupName);
       group->ParentGroup->Subgroups.push_back(group);
     } else {
       group->ParentGroup = nullptr;
diff --git a/Source/CPack/cmCPackNSISGenerator.cxx b/Source/CPack/cmCPackNSISGenerator.cxx
index 2109b4e349..435f0ec2be 100644
--- a/Source/CPack/cmCPackNSISGenerator.cxx
+++ b/Source/CPack/cmCPackNSISGenerator.cxx
@@ -31,7 +31,7 @@
 
 cmCPackNSISGenerator::cmCPackNSISGenerator(bool nsis64)
 {
-  Nsis64 = nsis64;
+  this->Nsis64 = nsis64;
 }
 
 cmCPackNSISGenerator::~cmCPackNSISGenerator() = default;
@@ -61,18 +61,18 @@ int cmCPackNSISGenerator::PackageFiles()
   std::string nsisInstallOptions = nsisFileName + "/NSIS.InstallOptions.ini";
   nsisFileName += "/project.nsi";
   std::ostringstream str;
-  for (std::string const& file : files) {
+  for (std::string const& file : this->files) {
     std::string outputDir = "$INSTDIR";
-    std::string fileN = cmSystemTools::RelativePath(toplevel, file);
+    std::string fileN = cmSystemTools::RelativePath(this->toplevel, file);
     if (!this->Components.empty()) {
       const std::string::size_type pos = fileN.find('/');
 
       // Use the custom component install directory if we have one
       if (pos != std::string::npos) {
         auto componentName = cm::string_view(fileN).substr(0, pos);
-        outputDir = CustomComponentInstallDirectory(componentName);
+        outputDir = this->CustomComponentInstallDirectory(componentName);
       } else {
-        outputDir = CustomComponentInstallDirectory(fileN);
+        outputDir = this->CustomComponentInstallDirectory(fileN);
       }
 
       // Strip off the component part of the path.
@@ -86,15 +86,15 @@ int cmCPackNSISGenerator::PackageFiles()
                 "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);
+  this->GetListOfSubdirectories(this->toplevel.c_str(), dirs);
   std::ostringstream dstr;
   for (std::string const& dir : dirs) {
     std::string componentName;
-    std::string fileN = cmSystemTools::RelativePath(toplevel, dir);
+    std::string fileN = cmSystemTools::RelativePath(this->toplevel, dir);
     if (fileN.empty()) {
       continue;
     }
-    if (!Components.empty()) {
+    if (!this->Components.empty()) {
       // If this is a component installation, strip off the component
       // part of the path.
       std::string::size_type slash = fileN.find('/');
@@ -110,7 +110,7 @@ int cmCPackNSISGenerator::PackageFiles()
     std::replace(fileN.begin(), fileN.end(), '/', '\\');
 
     const std::string componentOutputDir =
-      CustomComponentInstallDirectory(componentName);
+      this->CustomComponentInstallDirectory(componentName);
 
     dstr << "  RMDir \"" << componentOutputDir << "\\" << fileN << "\""
          << std::endl;
@@ -677,7 +677,7 @@ std::string cmCPackNSISGenerator::CreateComponentDescription(
   }
 
   const std::string componentOutputDir =
-    CustomComponentInstallDirectory(component->Name);
+    this->CustomComponentInstallDirectory(component->Name);
   componentCode += cmStrCat("  SetOutPath \"", componentOutputDir, "\"\n");
 
   // Create the actual installation commands
@@ -833,14 +833,16 @@ std::string cmCPackNSISGenerator::CreateComponentDescription(
   // depends on.
   std::set<cmCPackComponent*> visited;
   macrosOut << "!macro Select_" << component->Name << "_depends\n";
-  macrosOut << CreateSelectionDependenciesDescription(component, visited);
+  macrosOut << this->CreateSelectionDependenciesDescription(component,
+                                                            visited);
   macrosOut << "!macroend\n";
 
   // Macro used to deselect each of the components that depend on this
   // component.
   visited.clear();
   macrosOut << "!macro Deselect_required_by_" << component->Name << "\n";
-  macrosOut << CreateDeselectionDependenciesDescription(component, visited);
+  macrosOut << this->CreateDeselectionDependenciesDescription(component,
+                                                              visited);
   macrosOut << "!macroend\n";
   return componentCode;
 }
@@ -862,7 +864,8 @@ std::string cmCPackNSISGenerator::CreateSelectionDependenciesDescription(
     out << "  SectionSetFlags ${" << depend->Name << "} $0\n";
     out << "  IntOp $" << depend->Name << "_selected 0 + ${SF_SELECTED}\n";
     // Recurse
-    out << CreateSelectionDependenciesDescription(depend, visited).c_str();
+    out
+      << this->CreateSelectionDependenciesDescription(depend, visited).c_str();
   }
 
   return out.str();
@@ -887,7 +890,8 @@ std::string cmCPackNSISGenerator::CreateDeselectionDependenciesDescription(
     out << "  IntOp $" << depend->Name << "_selected 0 + 0\n";
 
     // Recurse
-    out << CreateDeselectionDependenciesDescription(depend, visited).c_str();
+    out << this->CreateDeselectionDependenciesDescription(depend, visited)
+             .c_str();
   }
 
   return out.str();
diff --git a/Source/CPack/cmCPackNuGetGenerator.cxx b/Source/CPack/cmCPackNuGetGenerator.cxx
index 60faecd0bb..98dc8906f0 100644
--- a/Source/CPack/cmCPackNuGetGenerator.cxx
+++ b/Source/CPack/cmCPackNuGetGenerator.cxx
@@ -17,32 +17,33 @@
 
 bool cmCPackNuGetGenerator::SupportsComponentInstallation() const
 {
-  return IsOn("CPACK_NUGET_COMPONENT_INSTALL");
+  return this->IsOn("CPACK_NUGET_COMPONENT_INSTALL");
 }
 
 int cmCPackNuGetGenerator::PackageFiles()
 {
-  cmCPackLogger(cmCPackLog::LOG_DEBUG, "Toplevel: " << toplevel << std::endl);
+  cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                "Toplevel: " << this->toplevel << std::endl);
 
   /* Reset package file name list it will be populated after the
    * `CPackNuGet.cmake` run */
-  packageFileNames.clear();
+  this->packageFileNames.clear();
 
   /* Are we in the component packaging case */
-  if (WantsComponentInstallation()) {
-    if (componentPackageMethod == ONE_PACKAGE) {
+  if (this->WantsComponentInstallation()) {
+    if (this->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);
+      this->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);
+      this->SetupGroupComponentVariables(this->componentPackageMethod ==
+                                         ONE_PACKAGE_PER_COMPONENT);
     }
   } else {
     // CASE 3 : NON COMPONENT package.
@@ -51,7 +52,7 @@ int cmCPackNuGetGenerator::PackageFiles()
 
   auto retval = this->ReadListFile("Internal/CPack/CPackNuGet.cmake");
   if (retval) {
-    AddGeneratedPackageNames();
+    this->AddGeneratedPackageNames();
   } else {
     cmCPackLogger(cmCPackLog::LOG_ERROR,
                   "Error while execution CPackNuGet.cmake" << std::endl);
@@ -133,9 +134,9 @@ void cmCPackNuGetGenerator::AddGeneratedPackageNames()
   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));
+    this->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));
+  this->packageFileNames.push_back(fileNames.substr(pos1, pos2 - pos1));
 }
diff --git a/Source/CPack/cmCPackRPMGenerator.cxx b/Source/CPack/cmCPackRPMGenerator.cxx
index 0c1cecf39c..c3f6d594b5 100644
--- a/Source/CPack/cmCPackRPMGenerator.cxx
+++ b/Source/CPack/cmCPackRPMGenerator.cxx
@@ -51,11 +51,11 @@ void cmCPackRPMGenerator::AddGeneratedPackageNames()
   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));
+    this->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));
+  this->packageFileNames.push_back(fileNames.substr(pos1, pos2 - pos1));
 }
 
 int cmCPackRPMGenerator::PackageOnePack(std::string const& initialToplevel,
@@ -64,10 +64,11 @@ int cmCPackRPMGenerator::PackageOnePack(std::string const& initialToplevel,
   int retval = 1;
   // Begin the archive for this pack
   std::string localToplevel(initialToplevel);
-  std::string packageFileName(cmSystemTools::GetParentDirectory(toplevel));
+  std::string packageFileName(
+    cmSystemTools::GetParentDirectory(this->toplevel));
   std::string outputFileName(
-    GetComponentPackageFileName(this->GetOption("CPACK_PACKAGE_FILE_NAME"),
-                                packageName, true) +
+    this->GetComponentPackageFileName(
+      this->GetOption("CPACK_PACKAGE_FILE_NAME"), packageName, true) +
     this->GetOutputExtension());
 
   localToplevel += "/" + packageName;
@@ -99,7 +100,7 @@ int cmCPackRPMGenerator::PackageComponents(bool ignoreGroup)
   int retval = 1;
   /* Reset package file name list it will be populated during the
    * component packaging run*/
-  packageFileNames.clear();
+  this->packageFileNames.clear();
   std::string initialTopLevel(this->GetOption("CPACK_TEMPORARY_DIRECTORY"));
 
   const char* mainComponent = this->GetOption("CPACK_RPM_MAIN_COMPONENT");
@@ -202,7 +203,7 @@ int cmCPackRPMGenerator::PackageComponents(bool ignoreGroup)
         cmCPackLogger(cmCPackLog::LOG_VERBOSE,
                       "Packaging component group: " << compGIt->first
                                                     << std::endl);
-        retval &= PackageOnePack(initialTopLevel, compGIt->first);
+        retval &= this->PackageOnePack(initialTopLevel, compGIt->first);
       }
       // Handle Orphan components (components not belonging to any groups)
       auto mainCompIt = this->Components.end();
@@ -227,7 +228,7 @@ int cmCPackRPMGenerator::PackageComponents(bool ignoreGroup)
               << compIt->second.Name
               << "> does not belong to any group, package it separately."
               << std::endl);
-          retval &= PackageOnePack(initialTopLevel, compIt->first);
+          retval &= this->PackageOnePack(initialTopLevel, compIt->first);
         }
       }
 
@@ -235,9 +236,9 @@ int cmCPackRPMGenerator::PackageComponents(bool ignoreGroup)
         this->SetOption("GENERATE_SPEC_PARTS", "OFF");
 
         if (mainCompGIt != this->ComponentGroups.end()) {
-          retval &= PackageOnePack(initialTopLevel, mainCompGIt->first);
+          retval &= this->PackageOnePack(initialTopLevel, mainCompGIt->first);
         } else if (mainCompIt != this->Components.end()) {
-          retval &= PackageOnePack(initialTopLevel, mainCompIt->first);
+          retval &= this->PackageOnePack(initialTopLevel, mainCompIt->first);
         } else {
           cmCPackLogger(cmCPackLog::LOG_ERROR,
                         "CPACK_RPM_MAIN_COMPONENT set"
@@ -264,14 +265,14 @@ int cmCPackRPMGenerator::PackageComponents(bool ignoreGroup)
           continue;
         }
 
-        retval &= PackageOnePack(initialTopLevel, compIt->first);
+        retval &= this->PackageOnePack(initialTopLevel, compIt->first);
       }
 
       if (retval) {
         this->SetOption("GENERATE_SPEC_PARTS", "OFF");
 
         if (mainCompIt != this->Components.end()) {
-          retval &= PackageOnePack(initialTopLevel, mainCompIt->first);
+          retval &= this->PackageOnePack(initialTopLevel, mainCompIt->first);
         } else {
           cmCPackLogger(cmCPackLog::LOG_ERROR,
                         "CPACK_RPM_MAIN_COMPONENT set"
@@ -291,7 +292,7 @@ int cmCPackRPMGenerator::PackageComponents(bool ignoreGroup)
         cmCPackLogger(cmCPackLog::LOG_VERBOSE,
                       "Packaging component group: " << compGIt->first
                                                     << std::endl);
-        retval &= PackageOnePack(initialTopLevel, compGIt->first);
+        retval &= this->PackageOnePack(initialTopLevel, compGIt->first);
       }
       // Handle Orphan components (components not belonging to any groups)
       std::map<std::string, cmCPackComponent>::iterator compIt;
@@ -305,7 +306,7 @@ int cmCPackRPMGenerator::PackageComponents(bool ignoreGroup)
               << compIt->second.Name
               << "> does not belong to any group, package it separately."
               << std::endl);
-          retval &= PackageOnePack(initialTopLevel, compIt->first);
+          retval &= this->PackageOnePack(initialTopLevel, compIt->first);
         }
       }
     }
@@ -315,7 +316,7 @@ int cmCPackRPMGenerator::PackageComponents(bool ignoreGroup)
       std::map<std::string, cmCPackComponent>::iterator compIt;
       for (compIt = this->Components.begin(); compIt != this->Components.end();
            ++compIt) {
-        retval &= PackageOnePack(initialTopLevel, compIt->first);
+        retval &= this->PackageOnePack(initialTopLevel, compIt->first);
       }
     }
   } else {
@@ -328,7 +329,7 @@ int cmCPackRPMGenerator::PackageComponents(bool ignoreGroup)
   }
 
   if (retval) {
-    AddGeneratedPackageNames();
+    this->AddGeneratedPackageNames();
   }
 
   return retval;
@@ -340,7 +341,7 @@ int cmCPackRPMGenerator::PackageComponentsAllInOne(
   int retval = 1;
   /* Reset package file name list it will be populated during the
    * component packaging run*/
-  packageFileNames.clear();
+  this->packageFileNames.clear();
   std::string initialTopLevel(this->GetOption("CPACK_TEMPORARY_DIRECTORY"));
 
   if (this->IsOn("CPACK_RPM_DEBUGINFO_SINGLE_PACKAGE")) {
@@ -354,7 +355,8 @@ int cmCPackRPMGenerator::PackageComponentsAllInOne(
 
   // The ALL GROUPS in ONE package case
   std::string localToplevel(initialTopLevel);
-  std::string packageFileName(cmSystemTools::GetParentDirectory(toplevel));
+  std::string packageFileName(
+    cmSystemTools::GetParentDirectory(this->toplevel));
   std::string outputFileName(
     std::string(this->GetOption("CPACK_PACKAGE_FILE_NAME")) +
     this->GetOutputExtension());
@@ -378,7 +380,7 @@ int cmCPackRPMGenerator::PackageComponentsAllInOne(
   }
 
   if (this->ReadListFile("Internal/CPack/CPackRPM.cmake")) {
-    AddGeneratedPackageNames();
+    this->AddGeneratedPackageNames();
   } else {
     cmCPackLogger(cmCPackLog::LOG_ERROR,
                   "Error while execution CPackRPM.cmake" << std::endl);
@@ -390,48 +392,49 @@ int cmCPackRPMGenerator::PackageComponentsAllInOne(
 
 int cmCPackRPMGenerator::PackageFiles()
 {
-  cmCPackLogger(cmCPackLog::LOG_DEBUG, "Toplevel: " << toplevel << std::endl);
+  cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                "Toplevel: " << this->toplevel << std::endl);
 
   /* Are we in the component packaging case */
-  if (WantsComponentInstallation()) {
+  if (this->WantsComponentInstallation()) {
     // CASE 1 : COMPONENT ALL-IN-ONE package
     // If ALL COMPONENTS in ONE package has been requested
     // then the package file is unique and should be open here.
-    if (componentPackageMethod == ONE_PACKAGE) {
-      return PackageComponentsAllInOne("ALL_COMPONENTS_IN_ONE");
+    if (this->componentPackageMethod == ONE_PACKAGE) {
+      return this->PackageComponentsAllInOne("ALL_COMPONENTS_IN_ONE");
     }
     // CASE 2 : COMPONENT CLASSICAL package(s) (i.e. not all-in-one)
     // There will be 1 package for each component group
     // however one may require to ignore component group and
     // in this case you'll get 1 package for each component.
-    return PackageComponents(componentPackageMethod ==
-                             ONE_PACKAGE_PER_COMPONENT);
+    return this->PackageComponents(this->componentPackageMethod ==
+                                   ONE_PACKAGE_PER_COMPONENT);
   }
   // CASE 3 : NON COMPONENT package.
-  return PackageComponentsAllInOne("");
+  return this->PackageComponentsAllInOne("");
 }
 
 bool cmCPackRPMGenerator::SupportsComponentInstallation() const
 {
-  return IsOn("CPACK_RPM_COMPONENT_INSTALL");
+  return this->IsOn("CPACK_RPM_COMPONENT_INSTALL");
 }
 
 std::string cmCPackRPMGenerator::GetComponentInstallDirNameSuffix(
   const std::string& componentName)
 {
-  if (componentPackageMethod == ONE_PACKAGE_PER_COMPONENT) {
+  if (this->componentPackageMethod == ONE_PACKAGE_PER_COMPONENT) {
     return componentName;
   }
 
-  if (componentPackageMethod == ONE_PACKAGE) {
+  if (this->componentPackageMethod == ONE_PACKAGE) {
     return std::string("ALL_COMPONENTS_IN_ONE");
   }
   // We have to find the name of the COMPONENT GROUP
   // the current COMPONENT belongs to.
   std::string groupVar =
     "CPACK_COMPONENT_" + cmSystemTools::UpperCase(componentName) + "_GROUP";
-  if (nullptr != GetOption(groupVar)) {
-    return std::string(GetOption(groupVar));
+  if (nullptr != this->GetOption(groupVar)) {
+    return std::string(this->GetOption(groupVar));
   }
   return componentName;
 }
diff --git a/Source/CPack/cmCPackSTGZGenerator.cxx b/Source/CPack/cmCPackSTGZGenerator.cxx
index a4a5e6fcd0..3e36e8cc18 100644
--- a/Source/CPack/cmCPackSTGZGenerator.cxx
+++ b/Source/CPack/cmCPackSTGZGenerator.cxx
@@ -50,7 +50,7 @@ int cmCPackSTGZGenerator::PackageFiles()
    * have generated several packages (component packaging)
    * so we must iterate over generated packages.
    */
-  for (std::string const& pfn : packageFileNames) {
+  for (std::string const& pfn : this->packageFileNames) {
     retval &= cmSystemTools::SetPermissions(pfn.c_str(),
 #if defined(_MSC_VER) || defined(__MINGW32__)
                                             S_IREAD | S_IWRITE | S_IEXEC
diff --git a/Source/CTest/cmCTestBZR.cxx b/Source/CTest/cmCTestBZR.cxx
index c533cd7f90..a35343549a 100644
--- a/Source/CTest/cmCTestBZR.cxx
+++ b/Source/CTest/cmCTestBZR.cxx
@@ -104,8 +104,8 @@ private:
   {
     if (this->RegexCheckOut.find(this->Line)) {
       this->BZR->URL = this->RegexCheckOut.match(1);
-      CheckOutFound = true;
-    } else if (!CheckOutFound && this->RegexParent.find(this->Line)) {
+      this->CheckOutFound = true;
+    } else if (!this->CheckOutFound && this->RegexParent.find(this->Line)) {
       this->BZR->URL = this->RegexParent.match(1);
     }
     return true;
@@ -191,7 +191,7 @@ public:
 
   int InitializeParser() override
   {
-    int res = cmXMLParser::InitializeParser();
+    int res = this->cmXMLParser::InitializeParser();
     if (res) {
       XML_SetUnknownEncodingHandler(static_cast<XML_Parser>(this->Parser),
                                     cmBZRXMLParserUnknownEncodingHandler,
diff --git a/Source/CTest/cmCTestBuildCommand.cxx b/Source/CTest/cmCTestBuildCommand.cxx
index 4151fde638..88e2871604 100644
--- a/Source/CTest/cmCTestBuildCommand.cxx
+++ b/Source/CTest/cmCTestBuildCommand.cxx
@@ -137,7 +137,7 @@ cmCTestGenericHandler* cmCTestBuildCommand::InitializeHandler()
 bool cmCTestBuildCommand::InitialPass(std::vector<std::string> const& args,
                                       cmExecutionStatus& status)
 {
-  bool ret = cmCTestHandlerCommand::InitialPass(args, status);
+  bool ret = this->cmCTestHandlerCommand::InitialPass(args, status);
   if (!this->NumberErrors.empty()) {
     this->Makefile->AddDefinition(
       this->NumberErrors, std::to_string(this->Handler->GetTotalErrors()));
diff --git a/Source/CTest/cmCTestCoverageHandler.cxx b/Source/CTest/cmCTestCoverageHandler.cxx
index 093b2d16dd..5fb52bf601 100644
--- a/Source/CTest/cmCTestCoverageHandler.cxx
+++ b/Source/CTest/cmCTestCoverageHandler.cxx
@@ -778,16 +778,16 @@ struct cmCTestCoverageHandlerLocale
   {
     std::string l;
     if (cmSystemTools::GetEnv("LC_ALL", l)) {
-      lc_all = l;
+      this->lc_all = l;
     }
-    if (lc_all != "C") {
+    if (this->lc_all != "C") {
       cmSystemTools::PutEnv("LC_ALL=C");
     }
   }
   ~cmCTestCoverageHandlerLocale()
   {
-    if (!lc_all.empty()) {
-      cmSystemTools::PutEnv("LC_ALL=" + lc_all);
+    if (!this->lc_all.empty()) {
+      cmSystemTools::PutEnv("LC_ALL=" + this->lc_all);
     } else {
       cmSystemTools::UnsetEnv("LC_ALL");
     }
diff --git a/Source/CTest/cmCTestLaunchReporter.cxx b/Source/CTest/cmCTestLaunchReporter.cxx
index 6ec7d0e395..f89fc9b56f 100644
--- a/Source/CTest/cmCTestLaunchReporter.cxx
+++ b/Source/CTest/cmCTestLaunchReporter.cxx
@@ -284,7 +284,7 @@ void cmCTestLaunchReporter::DumpFileToXML(cmXMLElement& e3, const char* tag,
 
   cmXMLElement e4(e3, tag);
   while (cmSystemTools::GetLineFromStream(fin, line)) {
-    if (MatchesFilterPrefix(line)) {
+    if (this->MatchesFilterPrefix(line)) {
       continue;
     }
     if (this->Match(line, this->RegexWarningSuppress)) {
diff --git a/Source/CTest/cmCTestMultiProcessHandler.cxx b/Source/CTest/cmCTestMultiProcessHandler.cxx
index a08cb34801..9793c5bb1e 100644
--- a/Source/CTest/cmCTestMultiProcessHandler.cxx
+++ b/Source/CTest/cmCTestMultiProcessHandler.cxx
@@ -56,8 +56,8 @@ public:
   // Sorts tests in descending order of cost
   bool operator()(int index1, int index2) const
   {
-    return Handler->Properties[index1]->Cost >
-      Handler->Properties[index2]->Cost;
+    return this->Handler->Properties[index1]->Cost >
+      this->Handler->Properties[index2]->Cost;
   }
 
 private:
@@ -169,7 +169,7 @@ bool cmCTestMultiProcessHandler::StartTestProcess(int test)
   this->TestRunningMap[test] = true; // mark the test as running
   // now remove the test itself
   this->EraseTest(test);
-  this->RunningCount += GetProcessorsUsed(test);
+  this->RunningCount += this->GetProcessorsUsed(test);
 
   auto testRun = cm::make_unique<cmCTestRunTest>(*this);
 
@@ -552,12 +552,12 @@ void cmCTestMultiProcessHandler::StartNextTests()
       continue;
     }
 
-    size_t processors = GetProcessorsUsed(test);
+    size_t processors = this->GetProcessorsUsed(test);
     bool testLoadOk = true;
     if (this->TestLoad > 0) {
       if (processors <= spareLoad) {
         cmCTestLog(this->CTest, DEBUG,
-                   "OK to run " << GetName(test) << ", it requires "
+                   "OK to run " << this->GetName(test) << ", it requires "
                                 << processors << " procs & system load is: "
                                 << systemLoad << std::endl);
         allTestsFailedTestLoadCheck = false;
@@ -568,7 +568,7 @@ void cmCTestMultiProcessHandler::StartNextTests()
 
     if (processors <= minProcessorsRequired) {
       minProcessorsRequired = processors;
-      testWithMinProcessors = GetName(test);
+      testWithMinProcessors = this->GetName(test);
     }
 
     if (testLoadOk && processors <= numToStart && this->StartTest(test)) {
@@ -660,7 +660,7 @@ void cmCTestMultiProcessHandler::FinishTestProcess(
   this->WriteCheckpoint(test);
   this->DeallocateResources(test);
   this->UnlockResources(test);
-  this->RunningCount -= GetProcessorsUsed(test);
+  this->RunningCount -= this->GetProcessorsUsed(test);
 
   for (auto p : properties->Affinity) {
     this->ProcessorsAvailable.insert(p);
@@ -793,9 +793,9 @@ int cmCTestMultiProcessHandler::SearchByName(std::string const& name)
 void cmCTestMultiProcessHandler::CreateTestCostList()
 {
   if (this->ParallelLevel > 1) {
-    CreateParallelTestCostList();
+    this->CreateParallelTestCostList();
   } else {
-    CreateSerialTestCostList();
+    this->CreateSerialTestCostList();
   }
 }
 
@@ -862,7 +862,7 @@ void cmCTestMultiProcessHandler::GetAllTestDependencies(int test,
 {
   TestSet const& dependencySet = this->Tests[test];
   for (int i : dependencySet) {
-    GetAllTestDependencies(i, dependencies);
+    this->GetAllTestDependencies(i, dependencies);
     dependencies.push_back(i);
   }
 }
@@ -886,7 +886,7 @@ void cmCTestMultiProcessHandler::CreateSerialTestCostList()
     }
 
     TestList dependencies;
-    GetAllTestDependencies(test, dependencies);
+    this->GetAllTestDependencies(test, dependencies);
 
     for (int testDependency : dependencies) {
       if (!cm::contains(alreadySortedTests, testDependency)) {
@@ -1274,7 +1274,7 @@ void cmCTestMultiProcessHandler::PrintOutputAsJson()
 void cmCTestMultiProcessHandler::PrintTestList()
 {
   if (this->CTest->GetOutputAsJson()) {
-    PrintOutputAsJson();
+    this->PrintOutputAsJson();
     return;
   }
 
diff --git a/Source/CTest/cmCTestP4.cxx b/Source/CTest/cmCTestP4.cxx
index 1375be406c..50c9c16f87 100644
--- a/Source/CTest/cmCTestP4.cxx
+++ b/Source/CTest/cmCTestP4.cxx
@@ -56,7 +56,7 @@ public:
   ChangesParser(cmCTestP4* p4, const char* prefix)
     : P4(p4)
   {
-    this->SetLog(&P4->Log, prefix);
+    this->SetLog(&this->P4->Log, prefix);
     this->RegexIdentify.compile("^Change ([0-9]+) on");
   }
 
@@ -67,7 +67,7 @@ private:
   bool ProcessLine() override
   {
     if (this->RegexIdentify.find(this->Line)) {
-      P4->ChangeLists.push_back(this->RegexIdentify.match(1));
+      this->P4->ChangeLists.push_back(this->RegexIdentify.match(1));
     }
     return true;
   }
@@ -79,7 +79,7 @@ public:
   UserParser(cmCTestP4* p4, const char* prefix)
     : P4(p4)
   {
-    this->SetLog(&P4->Log, prefix);
+    this->SetLog(&this->P4->Log, prefix);
     this->RegexUser.compile("^(.+) <(.*)> \\((.*)\\) accessed (.*)$");
   }
 
@@ -96,7 +96,7 @@ private:
       NewUser.EMail = this->RegexUser.match(2);
       NewUser.Name = this->RegexUser.match(3);
       NewUser.AccessTime = this->RegexUser.match(4);
-      P4->Users[this->RegexUser.match(1)] = NewUser;
+      this->P4->Users[this->RegexUser.match(1)] = NewUser;
 
       return false;
     }
@@ -120,7 +120,7 @@ public:
     : P4(p4)
     , AlreadyNotified(false)
   {
-    this->SetLog(&P4->Log, prefix);
+    this->SetLog(&this->P4->Log, prefix);
     this->RegexDiff.compile("^==== (.*)#[0-9]+ - (.*)");
   }
 
@@ -134,12 +134,12 @@ private:
   {
     if (!this->Line.empty() && this->Line[0] == '=' &&
         this->RegexDiff.find(this->Line)) {
-      CurrentPath = this->RegexDiff.match(1);
-      AlreadyNotified = false;
+      this->CurrentPath = this->RegexDiff.match(1);
+      this->AlreadyNotified = false;
     } else {
-      if (!AlreadyNotified) {
-        P4->DoModification(PathModified, CurrentPath);
-        AlreadyNotified = true;
+      if (!this->AlreadyNotified) {
+        this->P4->DoModification(PathModified, this->CurrentPath);
+        this->AlreadyNotified = true;
       }
     }
     return true;
@@ -148,11 +148,11 @@ private:
 
 cmCTestP4::User cmCTestP4::GetUserData(const std::string& username)
 {
-  auto it = Users.find(username);
+  auto it = this->Users.find(username);
 
-  if (it == Users.end()) {
+  if (it == this->Users.end()) {
     std::vector<char const*> p4_users;
-    SetP4Options(p4_users);
+    this->SetP4Options(p4_users);
     p4_users.push_back("users");
     p4_users.push_back("-m");
     p4_users.push_back("1");
@@ -161,11 +161,11 @@ cmCTestP4::User cmCTestP4::GetUserData(const std::string& username)
 
     UserParser out(this, "users-out> ");
     OutputLogger err(this->Log, "users-err> ");
-    RunChild(&p4_users[0], &out, &err);
+    this->RunChild(&p4_users[0], &out, &err);
 
     // The user should now be added to the map. Search again.
-    it = Users.find(username);
-    if (it == Users.end()) {
+    it = this->Users.find(username);
+    if (it == this->Users.end()) {
       return cmCTestP4::User();
     }
   }
@@ -195,7 +195,7 @@ public:
     , P4(p4)
     , Section(SectionHeader)
   {
-    this->SetLog(&P4->Log, prefix);
+    this->SetLog(&this->P4->Log, prefix);
     this->RegexHeader.compile("^Change ([0-9]+) by (.+)@(.+) on (.*)$");
     this->RegexDiff.compile(R"(^\.\.\. (.*)#[0-9]+ ([^ ]+)$)");
   }
@@ -259,7 +259,7 @@ private:
       this->Rev.Rev = this->RegexHeader.match(1);
       this->Rev.Date = this->RegexHeader.match(4);
 
-      cmCTestP4::User user = P4->GetUserData(this->RegexHeader.match(2));
+      cmCTestP4::User user = this->P4->GetUserData(this->RegexHeader.match(2));
       this->Rev.Author = user.Name;
       this->Rev.EMail = user.EMail;
 
@@ -300,38 +300,38 @@ private:
         change.Action = 'M';
       }
 
-      Changes.push_back(change);
+      this->Changes.push_back(change);
     }
   }
 };
 
 void cmCTestP4::SetP4Options(std::vector<char const*>& CommandOptions)
 {
-  if (P4Options.empty()) {
+  if (this->P4Options.empty()) {
     const char* p4 = this->CommandLineTool.c_str();
-    P4Options.emplace_back(p4);
+    this->P4Options.emplace_back(p4);
 
     // The CTEST_P4_CLIENT variable sets the P4 client used when issuing
     // Perforce commands, if it's different from the default one.
     std::string client = this->CTest->GetCTestConfiguration("P4Client");
     if (!client.empty()) {
-      P4Options.emplace_back("-c");
-      P4Options.push_back(client);
+      this->P4Options.emplace_back("-c");
+      this->P4Options.push_back(client);
     }
 
     // Set the message language to be English, in case the P4 admin
     // has localized them
-    P4Options.emplace_back("-L");
-    P4Options.emplace_back("en");
+    this->P4Options.emplace_back("-L");
+    this->P4Options.emplace_back("en");
 
     // The CTEST_P4_OPTIONS variable adds additional Perforce command line
     // options before the main command
     std::string opts = this->CTest->GetCTestConfiguration("P4Options");
-    cm::append(P4Options, cmSystemTools::ParseArguments(opts));
+    cm::append(this->P4Options, cmSystemTools::ParseArguments(opts));
   }
 
   CommandOptions.clear();
-  for (std::string const& o : P4Options) {
+  for (std::string const& o : this->P4Options) {
     CommandOptions.push_back(o.c_str());
   }
 }
@@ -339,7 +339,7 @@ void cmCTestP4::SetP4Options(std::vector<char const*>& CommandOptions)
 std::string cmCTestP4::GetWorkingRevision()
 {
   std::vector<char const*> p4_identify;
-  SetP4Options(p4_identify);
+  this->SetP4Options(p4_identify);
 
   p4_identify.push_back("changes");
   p4_identify.push_back("-m");
@@ -354,7 +354,7 @@ std::string cmCTestP4::GetWorkingRevision()
   IdentifyParser out(this, "p4_changes-out> ", rev);
   OutputLogger err(this->Log, "p4_changes-err> ");
 
-  bool result = RunChild(&p4_identify[0], &out, &err);
+  bool result = this->RunChild(&p4_identify[0], &out, &err);
 
   // If there was a problem contacting the server return "<unknown>"
   if (!result) {
@@ -391,7 +391,7 @@ bool cmCTestP4::NoteNewRevision()
 bool cmCTestP4::LoadRevisions()
 {
   std::vector<char const*> p4_changes;
-  SetP4Options(p4_changes);
+  this->SetP4Options(p4_changes);
 
   // Use 'p4 changes ...@old,new' to get a list of changelists
   std::string range = this->SourceDirectory + "/...";
@@ -417,17 +417,17 @@ bool cmCTestP4::LoadRevisions()
   ChangesParser out(this, "p4_changes-out> ");
   OutputLogger err(this->Log, "p4_changes-err> ");
 
-  ChangeLists.clear();
+  this->ChangeLists.clear();
   this->RunChild(&p4_changes[0], &out, &err);
 
-  if (ChangeLists.empty()) {
+  if (this->ChangeLists.empty()) {
     return true;
   }
 
   // p4 describe -s ...@1111111,2222222
   std::vector<char const*> p4_describe;
-  for (std::string const& i : cmReverseRange(ChangeLists)) {
-    SetP4Options(p4_describe);
+  for (std::string const& i : cmReverseRange(this->ChangeLists)) {
+    this->SetP4Options(p4_describe);
     p4_describe.push_back("describe");
     p4_describe.push_back("-s");
     p4_describe.push_back(i.c_str());
@@ -443,7 +443,7 @@ bool cmCTestP4::LoadRevisions()
 bool cmCTestP4::LoadModifications()
 {
   std::vector<char const*> p4_diff;
-  SetP4Options(p4_diff);
+  this->SetP4Options(p4_diff);
 
   p4_diff.push_back("diff");
 
@@ -491,7 +491,7 @@ bool cmCTestP4::UpdateImpl()
   }
 
   std::vector<char const*> p4_sync;
-  SetP4Options(p4_sync);
+  this->SetP4Options(p4_sync);
 
   p4_sync.push_back("sync");
 
diff --git a/Source/CTest/cmCTestRunTest.cxx b/Source/CTest/cmCTestRunTest.cxx
index 4d65c9bda4..4ba0ae112d 100644
--- a/Source/CTest/cmCTestRunTest.cxx
+++ b/Source/CTest/cmCTestRunTest.cxx
@@ -198,7 +198,7 @@ bool cmCTestRunTest::EndTest(size_t completed, size_t total, bool started)
   if (this->CTest->GetTestProgressOutput()) {
     if (!passed) {
       // If the test did not pass, reprint test name and error
-      std::string output = GetTestPrefix(completed, total);
+      std::string output = this->GetTestPrefix(completed, total);
       std::string testName = this->TestProperties->Name;
       const int maxTestNameWidth = this->CTest->GetMaxTestNameWidth();
       testName.resize(maxTestNameWidth + 4, '.');
@@ -211,8 +211,8 @@ bool cmCTestRunTest::EndTest(size_t completed, size_t total, bool started)
       cmCTestLog(this->CTest, HANDLER_TEST_PROGRESS_OUTPUT, "\n"); // flush
     }
     if (completed == total) {
-      std::string testName =
-        GetTestPrefix(completed, total) + this->TestProperties->Name + "\n";
+      std::string testName = this->GetTestPrefix(completed, total) +
+        this->TestProperties->Name + "\n";
       cmCTestLog(this->CTest, HANDLER_TEST_PROGRESS_OUTPUT, testName);
     }
   }
@@ -485,8 +485,8 @@ bool cmCTestRunTest::StartTest(size_t completed, size_t total)
                  << this->TestProperties->Index << ": "
                  << this->TestProperties->Name << std::endl);
   } else {
-    std::string testName =
-      GetTestPrefix(completed, total) + this->TestProperties->Name + "\n";
+    std::string testName = this->GetTestPrefix(completed, total) +
+      this->TestProperties->Name + "\n";
     cmCTestLog(this->CTest, HANDLER_TEST_PROGRESS_OUTPUT, testName);
   }
 
diff --git a/Source/CTest/cmCTestSVN.cxx b/Source/CTest/cmCTestSVN.cxx
index 44dfab2e60..4692dbd516 100644
--- a/Source/CTest/cmCTestSVN.cxx
+++ b/Source/CTest/cmCTestSVN.cxx
@@ -286,9 +286,9 @@ bool cmCTestSVN::RunSVNCommand(std::vector<char const*> const& parameters,
   args.push_back(nullptr);
 
   if (strcmp(parameters[0], "update") == 0) {
-    return RunUpdateCommand(&args[0], out, err);
+    return this->RunUpdateCommand(&args[0], out, err);
   }
-  return RunChild(&args[0], out, err);
+  return this->RunChild(&args[0], out, err);
 }
 
 class cmCTestSVN::LogParser
@@ -328,7 +328,7 @@ private:
     this->CData.clear();
     if (name == "logentry") {
       this->Rev = Revision();
-      this->Rev.SVNInfo = &SVNRepo;
+      this->Rev.SVNInfo = &this->SVNRepo;
       if (const char* rev =
             cmCTestSVN::LogParser::FindAttribute(atts, "revision")) {
         this->Rev.Rev = rev;
@@ -354,7 +354,7 @@ private:
       this->SVN->DoRevisionSVN(this->Rev, this->Changes);
     } else if (!this->CData.empty() && name == "path") {
       std::string orig_path(&this->CData[0], this->CData.size());
-      std::string new_path = SVNRepo.BuildLocalPath(orig_path);
+      std::string new_path = this->SVNRepo.BuildLocalPath(orig_path);
       this->CurChange.Path.assign(new_path);
       this->Changes.push_back(this->CurChange);
     } else if (!this->CData.empty() && name == "author") {
diff --git a/Source/CTest/cmCTestTestHandler.cxx b/Source/CTest/cmCTestTestHandler.cxx
index 84bb79106e..a8c9df687a 100644
--- a/Source/CTest/cmCTestTestHandler.cxx
+++ b/Source/CTest/cmCTestTestHandler.cxx
@@ -340,7 +340,7 @@ void cmCTestTestHandler::Initialize()
   this->ExcludeFixtureSetupRegExp.clear();
   this->ExcludeFixtureCleanupRegExp.clear();
 
-  TestsToRunString.clear();
+  this->TestsToRunString.clear();
   this->UseUnion = false;
   this->TestList.clear();
 }
@@ -877,7 +877,7 @@ bool cmCTestTestHandler::ComputeTestList()
     finalList.push_back(tp);
   }
 
-  UpdateForFixtures(finalList);
+  this->UpdateForFixtures(finalList);
 
   // Save the total number of tests before exclusions
   this->TotalNumberOfTests = this->TestList.size();
@@ -906,7 +906,7 @@ void cmCTestTestHandler::ComputeTestListForRerunFailed()
     finalList.push_back(tp);
   }
 
-  UpdateForFixtures(finalList);
+  this->UpdateForFixtures(finalList);
 
   // Save the total number of tests before exclusions
   this->TotalNumberOfTests = this->TestList.size();
diff --git a/Source/CTest/cmParseBlanketJSCoverage.cxx b/Source/CTest/cmParseBlanketJSCoverage.cxx
index 409025f80c..3a6651f8f9 100644
--- a/Source/CTest/cmParseBlanketJSCoverage.cxx
+++ b/Source/CTest/cmParseBlanketJSCoverage.cxx
@@ -66,7 +66,7 @@ public:
         }
         foundFile = true;
         inSource = false;
-        filename = getValue(line, 0);
+        filename = this->getValue(line, 0);
       } else if ((line.find("coverage") != std::string::npos) && foundFile &&
                  inSource) {
         /*
@@ -78,7 +78,7 @@ public:
          *  FoundFile and foundSource ensure that
          *  only the value of the line coverage is captured
          */
-        std::string result = getValue(line, 1);
+        std::string result = this->getValue(line, 1);
         result = result.substr(2);
         if (result == "\"\"") {
           // Empty quotation marks indicate that the
diff --git a/Source/CTest/cmParseCoberturaCoverage.cxx b/Source/CTest/cmParseCoberturaCoverage.cxx
index 711a8564ba..93117695c7 100644
--- a/Source/CTest/cmParseCoberturaCoverage.cxx
+++ b/Source/CTest/cmParseCoberturaCoverage.cxx
@@ -66,7 +66,7 @@ protected:
 
           // Check if this is an absolute path that falls within our
           // source or binary directories.
-          for (std::string const& filePath : FilePaths) {
+          for (std::string const& filePath : this->FilePaths) {
             if (cmHasPrefix(filename, filePath)) {
               this->CurFileName = filename;
               break;
@@ -76,7 +76,7 @@ protected:
           if (this->CurFileName.empty()) {
             // Check if this is a path that is relative to our source or
             // binary directories.
-            for (std::string const& filePath : FilePaths) {
+            for (std::string const& filePath : this->FilePaths) {
               finalpath = cmStrCat(filePath, "/", filename);
               if (cmSystemTools::FileExists(finalpath)) {
                 this->CurFileName = finalpath;
diff --git a/Source/CTest/cmParseDelphiCoverage.cxx b/Source/CTest/cmParseDelphiCoverage.cxx
index 016e90c02f..640873e2be 100644
--- a/Source/CTest/cmParseDelphiCoverage.cxx
+++ b/Source/CTest/cmParseDelphiCoverage.cxx
@@ -133,7 +133,7 @@ public:
     cmsys::Glob gl;
     gl.RecurseOn();
     gl.RecurseThroughSymlinksOff();
-    std::string glob = Coverage.SourceDir + "*/" + filename;
+    std::string glob = this->Coverage.SourceDir + "*/" + filename;
     gl.FindFiles(glob);
     std::vector<std::string> const& files = gl.GetFiles();
     if (files.empty()) {
diff --git a/Source/CTest/cmProcess.cxx b/Source/CTest/cmProcess.cxx
index 9ee1c170c2..c7cbd34d15 100644
--- a/Source/CTest/cmProcess.cxx
+++ b/Source/CTest/cmProcess.cxx
@@ -177,7 +177,7 @@ bool cmProcess::Buffer::GetLine(std::string& line)
 
       // Start a new range for the next line.
       ++this->Last;
-      this->First = Last;
+      this->First = this->Last;
 
       // Return the line extracted.
       return true;
diff --git a/Source/bindexplib.cxx b/Source/bindexplib.cxx
index 8435740139..0dc954aa47 100644
--- a/Source/bindexplib.cxx
+++ b/Source/bindexplib.cxx
@@ -467,7 +467,7 @@ bool DumpFile(std::string const& nmPath, const char* filename,
 
 bool bindexplib::AddObjectFile(const char* filename)
 {
-  return DumpFile(NmPath, filename, this->Symbols, this->DataSymbols);
+  return DumpFile(this->NmPath, filename, this->Symbols, this->DataSymbols);
 }
 
 bool bindexplib::AddDefinitionFile(const char* filename)
@@ -511,5 +511,5 @@ void bindexplib::WriteFile(FILE* file)
 
 void bindexplib::SetNmPath(std::string const& nm)
 {
-  NmPath = nm;
+  this->NmPath = nm;
 }
diff --git a/Source/cmAlgorithms.h b/Source/cmAlgorithms.h
index 87000da526..c192e2a7bc 100644
--- a/Source/cmAlgorithms.h
+++ b/Source/cmAlgorithms.h
@@ -47,7 +47,8 @@ struct BinarySearcher
 
   bool operator()(argument_type const& item) const
   {
-    return std::binary_search(m_range.begin(), m_range.end(), item);
+    return std::binary_search(this->m_range.begin(), this->m_range.end(),
+                              item);
   }
 
 private:
diff --git a/Source/cmArchiveWrite.h b/Source/cmArchiveWrite.h
index 0d33758d87..168d30e120 100644
--- a/Source/cmArchiveWrite.h
+++ b/Source/cmArchiveWrite.h
@@ -26,7 +26,7 @@ public:
   }
   void Clear() { this->IsValueSet = false; }
   bool IsSet() const { return this->IsValueSet; }
-  T Get() const { return Value; }
+  T Get() const { return this->Value; }
 
 private:
   T Value;
diff --git a/Source/cmCMakePathCommand.cxx b/Source/cmCMakePathCommand.cxx
index 85e7d9ed8c..e9bf84ab24 100644
--- a/Source/cmCMakePathCommand.cxx
+++ b/Source/cmCMakePathCommand.cxx
@@ -37,7 +37,7 @@ public:
   template <typename T>
   CMakePathArgumentParser& Bind(cm::static_string_view name, T Result::*member)
   {
-    cmArgumentParser<Result>::Bind(name, member);
+    this->cmArgumentParser<Result>::Bind(name, member);
     return *this;
   }
 
@@ -48,12 +48,12 @@ public:
   {
     this->Inputs.clear();
 
-    return cmArgumentParser<Result>::Parse(cmMakeRange(args).advance(Advance),
-                                           &this->Inputs, keywordsMissingValue,
-                                           parsedKeywords);
+    return this->cmArgumentParser<Result>::Parse(
+      cmMakeRange(args).advance(Advance), &this->Inputs, keywordsMissingValue,
+      parsedKeywords);
   }
 
-  const std::vector<std::string>& GetInputs() const { return Inputs; }
+  const std::vector<std::string>& GetInputs() const { return this->Inputs; }
 
 protected:
   mutable std::vector<std::string> Inputs;
@@ -74,7 +74,7 @@ public:
   ArgumentParserWithOutputVariable& Bind(cm::static_string_view name,
                                          T Result::*member)
   {
-    cmArgumentParser<Result>::Bind(name, member);
+    this->cmArgumentParser<Result>::Bind(name, member);
     return *this;
   }
 
@@ -84,7 +84,7 @@ public:
     this->KeywordsMissingValue.clear();
     this->ParsedKeywords.clear();
 
-    return CMakePathArgumentParser<Result>::template Parse<Advance>(
+    return this->CMakePathArgumentParser<Result>::template Parse<Advance>(
       args, &this->KeywordsMissingValue, &this->ParsedKeywords);
   }
 
diff --git a/Source/cmCTest.cxx b/Source/cmCTest.cxx
index 014ce4e59a..6507f38a91 100644
--- a/Source/cmCTest.cxx
+++ b/Source/cmCTest.cxx
@@ -1326,11 +1326,11 @@ int cmCTest::RunTest(std::vector<const char*> argv, std::string* output,
   if (result == cmsysProcess_State_Exited) {
     *retVal = cmsysProcess_GetExitValue(cp);
     if (*retVal != 0 && this->Impl->OutputTestOutputOnTestFailure) {
-      OutputTestErrors(tempOutput);
+      this->OutputTestErrors(tempOutput);
     }
   } else if (result == cmsysProcess_State_Exception) {
     if (this->Impl->OutputTestOutputOnTestFailure) {
-      OutputTestErrors(tempOutput);
+      this->OutputTestErrors(tempOutput);
     }
     *retVal = cmsysProcess_GetExitException(cp);
     std::string outerr = cmStrCat("\n*** Exception executing: ",
diff --git a/Source/cmCommandArgumentParserHelper.cxx b/Source/cmCommandArgumentParserHelper.cxx
index d4f502226f..6d5e064f5d 100644
--- a/Source/cmCommandArgumentParserHelper.cxx
+++ b/Source/cmCommandArgumentParserHelper.cxx
@@ -240,7 +240,7 @@ int cmCommandArgumentParserHelper::ParseString(std::string const& str,
 
   this->CleanupParser();
 
-  if (Verbose) {
+  if (this->Verbose) {
     std::cerr << "Expanding [" << str << "] produced: [" << this->Result << "]"
               << std::endl;
   }
diff --git a/Source/cmCommonTargetGenerator.cxx b/Source/cmCommonTargetGenerator.cxx
index 2b7c9f683f..228cff7ae1 100644
--- a/Source/cmCommonTargetGenerator.cxx
+++ b/Source/cmCommonTargetGenerator.cxx
@@ -27,7 +27,7 @@ cmCommonTargetGenerator::cmCommonTargetGenerator(cmGeneratorTarget* gt)
       static_cast<cmLocalCommonGenerator*>(gt->LocalGenerator))
   , GlobalCommonGenerator(static_cast<cmGlobalCommonGenerator*>(
       gt->LocalGenerator->GetGlobalGenerator()))
-  , ConfigNames(LocalCommonGenerator->GetConfigNames())
+  , ConfigNames(this->LocalCommonGenerator->GetConfigNames())
 {
 }
 
diff --git a/Source/cmComputeTargetDepends.cxx b/Source/cmComputeTargetDepends.cxx
index 1f22ce6342..85a9d9cf12 100644
--- a/Source/cmComputeTargetDepends.cxx
+++ b/Source/cmComputeTargetDepends.cxx
@@ -525,7 +525,7 @@ void cmComputeTargetDepends::DisplayGraph(Graph const& graph,
 void cmComputeTargetDepends::DisplaySideEffects()
 {
   fprintf(stderr, "The side effects are:\n");
-  int n = static_cast<int>(SideEffects.size());
+  int n = static_cast<int>(this->SideEffects.size());
   for (int depender_index = 0; depender_index < n; ++depender_index) {
     cmGeneratorTarget const* depender = this->Targets[depender_index];
     fprintf(stderr, "target %d is [%s]\n", depender_index,
diff --git a/Source/cmConditionEvaluator.cxx b/Source/cmConditionEvaluator.cxx
index 14f10bd747..62bc52691d 100644
--- a/Source/cmConditionEvaluator.cxx
+++ b/Source/cmConditionEvaluator.cxx
@@ -271,10 +271,10 @@ bool cmConditionEvaluator::GetBooleanValueWithAutoDereference(
 {
   // Use the policy if it is set.
   if (this->Policy12Status == cmPolicies::NEW) {
-    return GetBooleanValue(newArg);
+    return this->GetBooleanValue(newArg);
   }
   if (this->Policy12Status == cmPolicies::OLD) {
-    return GetBooleanValueOld(newArg, oneArg);
+    return this->GetBooleanValueOld(newArg, oneArg);
   }
 
   // Check policy only if old and new results differ.
@@ -367,7 +367,7 @@ bool cmConditionEvaluator::HandleLevel0(cmArgumentList& newArgs,
     reducible = 0;
     auto arg = newArgs.begin();
     while (arg != newArgs.end()) {
-      if (IsKeyword(keyParenL, *arg)) {
+      if (this->IsKeyword(keyParenL, *arg)) {
         // search for the closing paren for this opening one
         cmArgumentList::iterator argClose;
         argClose = arg;
@@ -531,7 +531,7 @@ bool cmConditionEvaluator::HandleLevel2(cmArgumentList& newArgs,
       argP1 = arg;
       this->IncrementArguments(newArgs, argP1, argP2);
       if (argP1 != newArgs.end() && argP2 != newArgs.end() &&
-          IsKeyword(keyMATCHES, *argP1)) {
+          this->IsKeyword(keyMATCHES, *argP1)) {
         def = this->GetDefinitionIfUnquoted(*arg);
         if (!def) {
           def = &arg->GetValue();
@@ -707,8 +707,8 @@ bool cmConditionEvaluator::HandleLevel3(cmArgumentList& newArgs,
     cmArgumentList::iterator argP2;
     while (arg != newArgs.end()) {
       argP1 = arg;
-      IncrementArguments(newArgs, argP1, argP2);
-      if (argP1 != newArgs.end() && IsKeyword(keyNOT, *arg)) {
+      this->IncrementArguments(newArgs, argP1, argP2);
+      if (argP1 != newArgs.end() && this->IsKeyword(keyNOT, *arg)) {
         bool rhs = this->GetBooleanValueWithAutoDereference(
           *argP1, errorString, status);
         this->HandlePredicate(!rhs, reducible, arg, newArgs, argP1, argP2);
@@ -735,8 +735,8 @@ bool cmConditionEvaluator::HandleLevel4(cmArgumentList& newArgs,
     cmArgumentList::iterator argP2;
     while (arg != newArgs.end()) {
       argP1 = arg;
-      IncrementArguments(newArgs, argP1, argP2);
-      if (argP1 != newArgs.end() && IsKeyword(keyAND, *argP1) &&
+      this->IncrementArguments(newArgs, argP1, argP2);
+      if (argP1 != newArgs.end() && this->IsKeyword(keyAND, *argP1) &&
           argP2 != newArgs.end()) {
         lhs =
           this->GetBooleanValueWithAutoDereference(*arg, errorString, status);
diff --git a/Source/cmCryptoHash.cxx b/Source/cmCryptoHash.cxx
index b1e63ba65d..b331862136 100644
--- a/Source/cmCryptoHash.cxx
+++ b/Source/cmCryptoHash.cxx
@@ -36,7 +36,7 @@ static rhash cmCryptoHash_rhash_init(unsigned int id)
 
 cmCryptoHash::cmCryptoHash(Algo algo)
   : Id(cmCryptoHashAlgoToId[algo])
-  , CTX(cmCryptoHash_rhash_init(Id))
+  , CTX(cmCryptoHash_rhash_init(this->Id))
 {
 }
 
diff --git a/Source/cmDependsCompiler.cxx b/Source/cmDependsCompiler.cxx
index beb080ffb3..73d7dc48c2 100644
--- a/Source/cmDependsCompiler.cxx
+++ b/Source/cmDependsCompiler.cxx
@@ -202,13 +202,13 @@ void cmDependsCompiler::WriteDependencies(
 
   // external dependencies file
   for (auto& node : makeDependencies) {
-    auto target = LocalGenerator->ConvertToMakefilePath(
+    auto target = this->LocalGenerator->ConvertToMakefilePath(
       this->LocalGenerator->MaybeConvertToRelativePath(binDir, node.first));
     auto& deps = node.second;
     std::transform(
       deps.cbegin(), deps.cend(), deps.begin(),
       [this, &binDir](const std::string& dep) {
-        return LocalGenerator->ConvertToMakefilePath(
+        return this->LocalGenerator->ConvertToMakefilePath(
           this->LocalGenerator->MaybeConvertToRelativePath(binDir, dep));
       });
 
diff --git a/Source/cmDocumentation.cxx b/Source/cmDocumentation.cxx
index 1bc453d371..3619aded5d 100644
--- a/Source/cmDocumentation.cxx
+++ b/Source/cmDocumentation.cxx
@@ -194,7 +194,7 @@ void cmDocumentation::addCTestStandardDocSections()
 {
   // This is currently done for backward compatibility reason
   // We may suppress some of these.
-  addCMakeStandardDocSections();
+  this->addCMakeStandardDocSections();
 }
 
 void cmDocumentation::addCPackStandardDocSections()
diff --git a/Source/cmELF.cxx b/Source/cmELF.cxx
index a8d81f7c24..deffdb6467 100644
--- a/Source/cmELF.cxx
+++ b/Source/cmELF.cxx
@@ -379,7 +379,7 @@ private:
 
     // Fix the byte order of the header.
     if (this->NeedSwap) {
-      ByteSwap(x);
+      this->ByteSwap(x);
     }
     return true;
   }
@@ -387,7 +387,7 @@ private:
   {
     if (this->Stream->read(reinterpret_cast<char*>(&x), sizeof(x)) &&
         this->NeedSwap) {
-      ByteSwap(x);
+      this->ByteSwap(x);
     }
     return !this->Stream->fail();
   }
@@ -395,7 +395,7 @@ private:
   {
     if (this->Stream->read(reinterpret_cast<char*>(&x), sizeof(x)) &&
         this->NeedSwap) {
-      ByteSwap(x);
+      this->ByteSwap(x);
     }
     return !this->Stream->fail();
   }
@@ -573,7 +573,7 @@ std::vector<char> cmELFInternalImpl<Types>::EncodeDynamicEntries(
     dyn.d_un.d_val = static_cast<tagtype>(entry.second);
 
     if (this->NeedSwap) {
-      ByteSwap(dyn);
+      this->ByteSwap(dyn);
     }
 
     char* pdyn = reinterpret_cast<char*>(&dyn);
diff --git a/Source/cmExprParserHelper.cxx b/Source/cmExprParserHelper.cxx
index 56dfc6c1d9..cc8b8b7e87 100644
--- a/Source/cmExprParserHelper.cxx
+++ b/Source/cmExprParserHelper.cxx
@@ -42,20 +42,22 @@ int cmExprParserHelper::ParseString(const char* str, int verb)
   try {
     int res = cmExpr_yyparse(yyscanner);
     if (res != 0) {
-      std::string e = cmStrCat("cannot parse the expression: \"", InputBuffer,
-                               "\": ", ErrorString, '.');
+      std::string e =
+        cmStrCat("cannot parse the expression: \"", this->InputBuffer,
+                 "\": ", this->ErrorString, '.');
       this->SetError(std::move(e));
     }
   } catch (std::runtime_error const& fail) {
-    std::string e = cmStrCat("cannot evaluate the expression: \"", InputBuffer,
-                             "\": ", fail.what(), '.');
+    std::string e = cmStrCat("cannot evaluate the expression: \"",
+                             this->InputBuffer, "\": ", fail.what(), '.');
     this->SetError(std::move(e));
   } catch (std::out_of_range const&) {
-    std::string e = "cannot evaluate the expression: \"" + InputBuffer +
+    std::string e = "cannot evaluate the expression: \"" + this->InputBuffer +
       "\": a numeric value is out of range.";
     this->SetError(std::move(e));
   } catch (...) {
-    std::string e = "cannot parse the expression: \"" + InputBuffer + "\".";
+    std::string e =
+      "cannot parse the expression: \"" + this->InputBuffer + "\".";
     this->SetError(std::move(e));
   }
   cmExpr_yylex_destroy(yyscanner);
@@ -63,7 +65,7 @@ int cmExprParserHelper::ParseString(const char* str, int verb)
     return 0;
   }
 
-  if (Verbose) {
+  if (this->Verbose) {
     std::cerr << "Expanding [" << str << "] produced: [" << this->Result << "]"
               << std::endl;
   }
diff --git a/Source/cmExternalMakefileProjectGenerator.h b/Source/cmExternalMakefileProjectGenerator.h
index 3ade67bea1..311a2efe71 100644
--- a/Source/cmExternalMakefileProjectGenerator.h
+++ b/Source/cmExternalMakefileProjectGenerator.h
@@ -52,8 +52,8 @@ public:
   //! Generate the project files, the Makefiles have already been generated
   virtual void Generate() = 0;
 
-  void SetName(const std::string& n) { Name = n; }
-  std::string GetName() const { return Name; }
+  void SetName(const std::string& n) { this->Name = n; }
+  std::string GetName() const { return this->Name; }
 
   virtual bool Open(const std::string& bindir, const std::string& projectName,
                     bool dryRun);
@@ -104,7 +104,7 @@ public:
   CreateExternalMakefileProjectGenerator() const override
   {
     std::unique_ptr<cmExternalMakefileProjectGenerator> p(new T);
-    p->SetName(GetName());
+    p->SetName(this->GetName());
     return p;
   }
 };
diff --git a/Source/cmExtraCodeBlocksGenerator.cxx b/Source/cmExtraCodeBlocksGenerator.cxx
index 87b8f9bd36..800db8a96e 100644
--- a/Source/cmExtraCodeBlocksGenerator.cxx
+++ b/Source/cmExtraCodeBlocksGenerator.cxx
@@ -112,10 +112,10 @@ void Tree::InsertPath(const std::vector<std::string>& split,
                       const std::string& fileName)
 {
   if (start == split.size()) {
-    files.insert(fileName);
+    this->files.insert(fileName);
     return;
   }
-  for (Tree& folder : folders) {
+  for (Tree& folder : this->folders) {
     if (folder.path == split[start]) {
       if (start + 1 < split.size()) {
         folder.InsertPath(split, start + 1, fileName);
@@ -131,19 +131,19 @@ void Tree::InsertPath(const std::vector<std::string>& split,
   newFolder.path = split[start];
   if (start + 1 < split.size()) {
     newFolder.InsertPath(split, start + 1, fileName);
-    folders.push_back(newFolder);
+    this->folders.push_back(newFolder);
     return;
   }
   // last part of split
   newFolder.files.insert(fileName);
-  folders.push_back(newFolder);
+  this->folders.push_back(newFolder);
 }
 
 void Tree::BuildVirtualFolder(cmXMLWriter& xml) const
 {
   xml.StartElement("Option");
   std::string virtualFolders = "CMake Files\\;";
-  for (Tree const& folder : folders) {
+  for (Tree const& folder : this->folders) {
     folder.BuildVirtualFolderImpl(virtualFolders, "");
   }
   xml.Attribute("virtualFolders", virtualFolders);
@@ -153,15 +153,15 @@ void Tree::BuildVirtualFolder(cmXMLWriter& xml) const
 void Tree::BuildVirtualFolderImpl(std::string& virtualFolders,
                                   const std::string& prefix) const
 {
-  virtualFolders += "CMake Files\\" + prefix + path + "\\;";
-  for (Tree const& folder : folders) {
-    folder.BuildVirtualFolderImpl(virtualFolders, prefix + path + "\\");
+  virtualFolders += "CMake Files\\" + prefix + this->path + "\\;";
+  for (Tree const& folder : this->folders) {
+    folder.BuildVirtualFolderImpl(virtualFolders, prefix + this->path + "\\");
   }
 }
 
 void Tree::BuildUnit(cmXMLWriter& xml, const std::string& fsPath) const
 {
-  for (std::string const& f : files) {
+  for (std::string const& f : this->files) {
     xml.StartElement("Unit");
     xml.Attribute("filename", fsPath + f);
 
@@ -171,7 +171,7 @@ void Tree::BuildUnit(cmXMLWriter& xml, const std::string& fsPath) const
 
     xml.EndElement();
   }
-  for (Tree const& folder : folders) {
+  for (Tree const& folder : this->folders) {
     folder.BuildUnitImpl(xml, "", fsPath);
   }
 }
@@ -180,20 +180,21 @@ void Tree::BuildUnitImpl(cmXMLWriter& xml,
                          const std::string& virtualFolderPath,
                          const std::string& fsPath) const
 {
-  for (std::string const& f : files) {
+  for (std::string const& f : this->files) {
     xml.StartElement("Unit");
-    xml.Attribute("filename", cmStrCat(fsPath, path, "/", f));
+    xml.Attribute("filename", cmStrCat(fsPath, this->path, "/", f));
 
     xml.StartElement("Option");
-    xml.Attribute("virtualFolder",
-                  cmStrCat("CMake Files\\", virtualFolderPath, path, "\\"));
+    xml.Attribute(
+      "virtualFolder",
+      cmStrCat("CMake Files\\", virtualFolderPath, this->path, "\\"));
     xml.EndElement();
 
     xml.EndElement();
   }
-  for (Tree const& folder : folders) {
-    folder.BuildUnitImpl(xml, cmStrCat(virtualFolderPath, path, "\\"),
-                         cmStrCat(fsPath, path, "/"));
+  for (Tree const& folder : this->folders) {
+    folder.BuildUnitImpl(xml, cmStrCat(virtualFolderPath, this->path, "\\"),
+                         cmStrCat(fsPath, this->path, "/"));
   }
 }
 
diff --git a/Source/cmExtraCodeLiteGenerator.cxx b/Source/cmExtraCodeLiteGenerator.cxx
index 95cfb0a451..549b08b4ef 100644
--- a/Source/cmExtraCodeLiteGenerator.cxx
+++ b/Source/cmExtraCodeLiteGenerator.cxx
@@ -64,7 +64,7 @@ void cmExtraCodeLiteGenerator::Generate()
   for (auto const& it : projectMap) {
     cmLocalGenerator* lg = it.second[0];
     const cmMakefile* mf = lg->GetMakefile();
-    this->ConfigName = GetConfigurationName(mf);
+    this->ConfigName = this->GetConfigurationName(mf);
 
     if (lg->GetCurrentBinaryDirectory() == lg->GetBinaryDirectory()) {
       workspaceOutputDir = lg->GetCurrentBinaryDirectory();
@@ -89,9 +89,9 @@ void cmExtraCodeLiteGenerator::Generate()
 
   std::vector<std::string> ProjectNames;
   if (targetsAreProjects) {
-    ProjectNames = CreateProjectsByTarget(&xml);
+    ProjectNames = this->CreateProjectsByTarget(&xml);
   } else {
-    ProjectNames = CreateProjectsByProjectMaps(&xml);
+    ProjectNames = this->CreateProjectsByProjectMaps(&xml);
   }
 
   xml.StartElement("BuildMatrix");
@@ -142,7 +142,7 @@ std::vector<std::string> cmExtraCodeLiteGenerator::CreateProjectsByTarget(
           xml->Attribute("Active", "No");
           xml->EndElement();
 
-          CreateNewProjectFile(lt.get(), filename);
+          this->CreateNewProjectFile(lt.get(), filename);
           break;
         default:
           break;
@@ -268,7 +268,7 @@ void cmExtraCodeLiteGenerator::CreateNewProjectFile(
     cmMakefile* makefile = lg->GetMakefile();
     for (const auto& target : lg->GetGeneratorTargets()) {
       projectType =
-        CollectSourceFiles(makefile, target.get(), cFiles, otherFiles);
+        this->CollectSourceFiles(makefile, target.get(), cFiles, otherFiles);
     }
   }
 
@@ -276,8 +276,8 @@ void cmExtraCodeLiteGenerator::CreateNewProjectFile(
   // their relative path)
   std::string projectPath = cmSystemTools::GetFilenamePath(filename);
 
-  CreateProjectSourceEntries(cFiles, otherFiles, &xml, projectPath, mf,
-                             projectType, "");
+  this->CreateProjectSourceEntries(cFiles, otherFiles, &xml, projectPath, mf,
+                                   projectType, "");
 
   xml.EndElement(); // CodeLite_Project
 }
@@ -402,7 +402,7 @@ void cmExtraCodeLiteGenerator::CreateProjectSourceEntries(
   const std::string& projectType, const std::string& targetName)
 {
   cmXMLWriter& xml(*_xml);
-  FindMatchingHeaderfiles(cFiles, otherFiles);
+  this->FindMatchingHeaderfiles(cFiles, otherFiles);
   // Create 2 virtual folders: src and include
   // and place all the implementation files into the src
   // folder, the rest goes to the include folder
@@ -498,10 +498,10 @@ void cmExtraCodeLiteGenerator::CreateProjectSourceEntries(
 
   xml.StartElement("CustomBuild");
   xml.Attribute("Enabled", "yes");
-  xml.Element("RebuildCommand", GetRebuildCommand(mf, targetName));
-  xml.Element("CleanCommand", GetCleanCommand(mf, targetName));
-  xml.Element("BuildCommand", GetBuildCommand(mf, targetName));
-  xml.Element("SingleFileCommand", GetSingleFileBuildCommand(mf));
+  xml.Element("RebuildCommand", this->GetRebuildCommand(mf, targetName));
+  xml.Element("CleanCommand", this->GetCleanCommand(mf, targetName));
+  xml.Element("BuildCommand", this->GetBuildCommand(mf, targetName));
+  xml.Element("SingleFileCommand", this->GetSingleFileBuildCommand(mf));
   xml.Element("PreprocessFileCommand");
   xml.Element("WorkingDirectory", "$(WorkspacePath)");
   xml.EndElement(); // CustomBuild
@@ -570,14 +570,14 @@ void cmExtraCodeLiteGenerator::CreateNewProjectFile(
   std::map<std::string, cmSourceFile*> cFiles;
   std::set<std::string> otherFiles;
 
-  projectType = CollectSourceFiles(mf, gt, cFiles, otherFiles);
+  projectType = this->CollectSourceFiles(mf, gt, cFiles, otherFiles);
 
   // Get the project path ( we need it later to convert files to
   // their relative path)
   std::string projectPath = cmSystemTools::GetFilenamePath(filename);
 
-  CreateProjectSourceEntries(cFiles, otherFiles, &xml, projectPath, mf,
-                             projectType, targetName);
+  this->CreateProjectSourceEntries(cFiles, otherFiles, &xml, projectPath, mf,
+                                   projectType, targetName);
 
   xml.EndElement(); // CodeLite_Project
 }
@@ -648,7 +648,7 @@ std::string cmExtraCodeLiteGenerator::GetCleanCommand(
 {
   std::string generator = mf->GetSafeDefinition("CMAKE_GENERATOR");
   std::ostringstream ss;
-  std::string buildcommand = GetBuildCommand(mf, "");
+  std::string buildcommand = this->GetBuildCommand(mf, "");
   if (!targetName.empty() && generator == "Ninja") {
     ss << buildcommand << " -t clean " << targetName;
   } else {
@@ -660,8 +660,8 @@ std::string cmExtraCodeLiteGenerator::GetCleanCommand(
 std::string cmExtraCodeLiteGenerator::GetRebuildCommand(
   const cmMakefile* mf, const std::string& targetName) const
 {
-  return GetCleanCommand(mf, targetName) + " && " +
-    GetBuildCommand(mf, targetName);
+  return this->GetCleanCommand(mf, targetName) + " && " +
+    this->GetBuildCommand(mf, targetName);
 }
 
 std::string cmExtraCodeLiteGenerator::GetSingleFileBuildCommand(
diff --git a/Source/cmExtraSublimeTextGenerator.cxx b/Source/cmExtraSublimeTextGenerator.cxx
index 249dfaf2d2..a92f6e3281 100644
--- a/Source/cmExtraSublimeTextGenerator.cxx
+++ b/Source/cmExtraSublimeTextGenerator.cxx
@@ -132,7 +132,7 @@ void cmExtraSublimeTextGenerator::CreateNewProjectFile(
   // doesn't currently support these settings per build system, only project
   // wide
   MapSourceFileFlags sourceFileFlags;
-  AppendAllTargets(lgs, mf, fout, sourceFileFlags);
+  this->AppendAllTargets(lgs, mf, fout, sourceFileFlags);
 
   // End of build_systems
   fout << "\n\t]";
diff --git a/Source/cmFileAPICMakeFiles.cxx b/Source/cmFileAPICMakeFiles.cxx
index 1e4f3b62bd..e208ca8ba2 100644
--- a/Source/cmFileAPICMakeFiles.cxx
+++ b/Source/cmFileAPICMakeFiles.cxx
@@ -41,7 +41,7 @@ CMakeFiles::CMakeFiles(cmFileAPI& fileAPI, unsigned long version)
   , CMakeModules(cmSystemTools::GetCMakeRoot() + "/Modules")
   , TopSource(this->FileAPI.GetCMakeInstance()->GetHomeDirectory())
   , TopBuild(this->FileAPI.GetCMakeInstance()->GetHomeOutputDirectory())
-  , OutOfSource(TopBuild != TopSource)
+  , OutOfSource(this->TopBuild != this->TopSource)
 {
   static_cast<void>(this->Version);
 }
@@ -50,7 +50,7 @@ Json::Value CMakeFiles::Dump()
 {
   Json::Value cmakeFiles = Json::objectValue;
   cmakeFiles["paths"] = this->DumpPaths();
-  cmakeFiles["inputs"] = DumpInputs();
+  cmakeFiles["inputs"] = this->DumpInputs();
   return cmakeFiles;
 }
 
diff --git a/Source/cmFileAPICache.cxx b/Source/cmFileAPICache.cxx
index 3ba943a45b..ddae5273b0 100644
--- a/Source/cmFileAPICache.cxx
+++ b/Source/cmFileAPICache.cxx
@@ -44,7 +44,7 @@ Cache::Cache(cmFileAPI& fileAPI, unsigned long version)
 Json::Value Cache::Dump()
 {
   Json::Value cache = Json::objectValue;
-  cache["entries"] = DumpEntries();
+  cache["entries"] = this->DumpEntries();
   return cache;
 }
 
diff --git a/Source/cmFileAPICodemodel.cxx b/Source/cmFileAPICodemodel.cxx
index 4a53c8a8c0..7fcc3dc73f 100644
--- a/Source/cmFileAPICodemodel.cxx
+++ b/Source/cmFileAPICodemodel.cxx
@@ -145,7 +145,7 @@ class JBTIndex
 {
 public:
   JBTIndex() = default;
-  explicit operator bool() const { return Index != None; }
+  explicit operator bool() const { return this->Index != None; }
   Json::ArrayIndex Index = None;
   static Json::ArrayIndex const None = static_cast<Json::ArrayIndex>(-1);
 };
diff --git a/Source/cmFilePathChecksum.cxx b/Source/cmFilePathChecksum.cxx
index bb3f610d12..6b52230ed8 100644
--- a/Source/cmFilePathChecksum.cxx
+++ b/Source/cmFilePathChecksum.cxx
@@ -16,15 +16,16 @@ cmFilePathChecksum::cmFilePathChecksum(std::string const& currentSrcDir,
                                        std::string const& projectSrcDir,
                                        std::string const& projectBinDir)
 {
-  setupParentDirs(currentSrcDir, currentBinDir, projectSrcDir, projectBinDir);
+  this->setupParentDirs(currentSrcDir, currentBinDir, projectSrcDir,
+                        projectBinDir);
 }
 
 cmFilePathChecksum::cmFilePathChecksum(cmMakefile* makefile)
 {
-  setupParentDirs(makefile->GetCurrentSourceDirectory(),
-                  makefile->GetCurrentBinaryDirectory(),
-                  makefile->GetHomeDirectory(),
-                  makefile->GetHomeOutputDirectory());
+  this->setupParentDirs(makefile->GetCurrentSourceDirectory(),
+                        makefile->GetCurrentBinaryDirectory(),
+                        makefile->GetHomeDirectory(),
+                        makefile->GetHomeOutputDirectory());
 }
 
 void cmFilePathChecksum::setupParentDirs(std::string const& currentSrcDir,
@@ -81,5 +82,5 @@ std::string cmFilePathChecksum::get(std::string const& filePath) const
 std::string cmFilePathChecksum::getPart(std::string const& filePath,
                                         size_t length) const
 {
-  return get(filePath).substr(0, length);
+  return this->get(filePath).substr(0, length);
 }
diff --git a/Source/cmFileTimes.cxx b/Source/cmFileTimes.cxx
index d8fe24c5b3..bd896f57a3 100644
--- a/Source/cmFileTimes.cxx
+++ b/Source/cmFileTimes.cxx
@@ -62,14 +62,14 @@ public:
 cmFileTimes::cmFileTimes() = default;
 cmFileTimes::cmFileTimes(std::string const& fileName)
 {
-  Load(fileName);
+  this->Load(fileName);
 }
 cmFileTimes::~cmFileTimes() = default;
 
 bool cmFileTimes::Load(std::string const& fileName)
 {
   std::unique_ptr<Times> ptr;
-  if (IsValid()) {
+  if (this->IsValid()) {
     // Invalidate this and re-use times
     ptr.swap(this->times);
   } else {
@@ -103,7 +103,7 @@ bool cmFileTimes::Load(std::string const& fileName)
 
 bool cmFileTimes::Store(std::string const& fileName) const
 {
-  if (!IsValid()) {
+  if (!this->IsValid()) {
     return false;
   }
 
diff --git a/Source/cmFileTimes.h b/Source/cmFileTimes.h
index f1916f7912..50d64fd97b 100644
--- a/Source/cmFileTimes.h
+++ b/Source/cmFileTimes.h
@@ -19,7 +19,7 @@ public:
   ~cmFileTimes();
 
   //! @return true, if file times were loaded successfully
-  bool IsValid() const { return (times != nullptr); }
+  bool IsValid() const { return (this->times != nullptr); }
   //! Try to load the file times from @a fileName and @return IsValid()
   bool Load(std::string const& fileName);
   //! Stores the file times at @a fileName (if IsValid())
diff --git a/Source/cmFindCommon.cxx b/Source/cmFindCommon.cxx
index 7952336fdd..d2f96197b8 100644
--- a/Source/cmFindCommon.cxx
+++ b/Source/cmFindCommon.cxx
@@ -289,7 +289,7 @@ void cmFindCommon::GetIgnoredPaths(std::vector<std::string>& ignore)
 void cmFindCommon::GetIgnoredPaths(std::set<std::string>& ignore)
 {
   std::vector<std::string> ignoreVec;
-  GetIgnoredPaths(ignoreVec);
+  this->GetIgnoredPaths(ignoreVec);
   ignore.insert(ignoreVec.begin(), ignoreVec.end());
 }
 
diff --git a/Source/cmFindLibraryCommand.cxx b/Source/cmFindLibraryCommand.cxx
index b87dfe396f..49b1bd74b3 100644
--- a/Source/cmFindLibraryCommand.cxx
+++ b/Source/cmFindLibraryCommand.cxx
@@ -31,7 +31,7 @@ cmFindLibraryCommand::cmFindLibraryCommand(cmExecutionStatus& status)
 // cmFindLibraryCommand
 bool cmFindLibraryCommand::InitialPass(std::vector<std::string> const& argsIn)
 {
-  this->DebugMode = ComputeIfDebugModeWanted();
+  this->DebugMode = this->ComputeIfDebugModeWanted();
   this->VariableDocumentation = "Path to a library.";
   this->CMakePathName = "LIBRARY";
   if (!this->ParseArguments(argsIn)) {
diff --git a/Source/cmFindPackageCommand.cxx b/Source/cmFindPackageCommand.cxx
index 92b1e80b8a..3b7cf4c3eb 100644
--- a/Source/cmFindPackageCommand.cxx
+++ b/Source/cmFindPackageCommand.cxx
@@ -144,7 +144,7 @@ bool cmFindPackageCommand::InitialPass(std::vector<std::string> const& args)
     this->RequiredCMakeVersion = CMake_VERSION_ENCODE(v[0], v[1], v[2]);
   }
 
-  this->DebugMode = ComputeIfDebugModeWanted();
+  this->DebugMode = this->ComputeIfDebugModeWanted();
   this->DebugBuffer.clear();
 
   // Lookup target architecture, if any.
@@ -534,7 +534,7 @@ bool cmFindPackageCommand::InitialPass(std::vector<std::string> const& args)
         loadedPackage = true;
       } else {
         // The package was not loaded. Report errors.
-        if (HandlePackageMode(HandlePackageModeType::Module)) {
+        if (this->HandlePackageMode(HandlePackageModeType::Module)) {
           loadedPackage = true;
         }
       }
@@ -2070,8 +2070,8 @@ public:
   void SetSort(cmFindPackageCommand::SortOrderType o,
                cmFindPackageCommand::SortDirectionType d)
   {
-    SortOrder = o;
-    SortDirection = d;
+    this->SortOrder = o;
+    this->SortDirection = d;
   }
 
 protected:
@@ -2102,8 +2102,8 @@ private:
     // before testing the matches check if there is a specific sorting order to
     // perform
     if (this->SortOrder != cmFindPackageCommand::None) {
-      cmFindPackageCommand::Sort(matches.begin(), matches.end(), SortOrder,
-                                 SortDirection);
+      cmFindPackageCommand::Sort(matches.begin(), matches.end(),
+                                 this->SortOrder, this->SortDirection);
     }
 
     for (std::string const& i : matches) {
diff --git a/Source/cmFindPathCommand.cxx b/Source/cmFindPathCommand.cxx
index 4bab469760..bece33ba7e 100644
--- a/Source/cmFindPathCommand.cxx
+++ b/Source/cmFindPathCommand.cxx
@@ -22,7 +22,7 @@ cmFindPathCommand::cmFindPathCommand(cmExecutionStatus& status)
 // cmFindPathCommand
 bool cmFindPathCommand::InitialPass(std::vector<std::string> const& argsIn)
 {
-  this->DebugMode = ComputeIfDebugModeWanted();
+  this->DebugMode = this->ComputeIfDebugModeWanted();
   this->VariableDocumentation = "Path to a file.";
   this->CMakePathName = "INCLUDE";
   if (!this->ParseArguments(argsIn)) {
diff --git a/Source/cmFindProgramCommand.cxx b/Source/cmFindProgramCommand.cxx
index 77728ec8a6..5bb4234660 100644
--- a/Source/cmFindProgramCommand.cxx
+++ b/Source/cmFindProgramCommand.cxx
@@ -152,7 +152,7 @@ cmFindProgramCommand::cmFindProgramCommand(cmExecutionStatus& status)
 // cmFindProgramCommand
 bool cmFindProgramCommand::InitialPass(std::vector<std::string> const& argsIn)
 {
-  this->DebugMode = ComputeIfDebugModeWanted();
+  this->DebugMode = this->ComputeIfDebugModeWanted();
   this->VariableDocumentation = "Path to a program.";
   this->CMakePathName = "PROGRAM";
   // call cmFindBase::ParseArguments
@@ -171,7 +171,7 @@ bool cmFindProgramCommand::InitialPass(std::vector<std::string> const& argsIn)
     return true;
   }
 
-  std::string const result = FindProgram();
+  std::string const result = this->FindProgram();
   if (!result.empty()) {
     // Save the value in the cache
     this->Makefile->AddCacheDefinition(this->VariableName, result,
@@ -198,7 +198,7 @@ std::string cmFindProgramCommand::FindProgram()
   std::string program;
 
   if (this->SearchAppBundleFirst || this->SearchAppBundleOnly) {
-    program = FindAppBundle();
+    program = this->FindAppBundle();
   }
   if (program.empty() && !this->SearchAppBundleOnly) {
     program = this->FindNormalProgram();
@@ -274,7 +274,7 @@ std::string cmFindProgramCommand::FindAppBundle()
       cmSystemTools::FindDirectory(appName, this->SearchPaths, true);
 
     if (!appPath.empty()) {
-      std::string executable = GetBundleExecutable(appPath);
+      std::string executable = this->GetBundleExecutable(appPath);
       if (!executable.empty()) {
         return cmSystemTools::CollapseFullPath(executable);
       }
diff --git a/Source/cmGeneratedFileStream.cxx b/Source/cmGeneratedFileStream.cxx
index 276854742b..43f384ab08 100644
--- a/Source/cmGeneratedFileStream.cxx
+++ b/Source/cmGeneratedFileStream.cxx
@@ -14,11 +14,11 @@
 #endif
 
 cmGeneratedFileStream::cmGeneratedFileStream(Encoding encoding)
-  : OriginalLocale(getloc())
+  : OriginalLocale(this->getloc())
 {
 #ifndef CMAKE_BOOTSTRAP
   if (encoding != codecvt::None) {
-    imbue(std::locale(OriginalLocale, new codecvt(encoding)));
+    this->imbue(std::locale(this->OriginalLocale, new codecvt(encoding)));
   }
 #else
   static_cast<void>(encoding);
@@ -28,7 +28,7 @@ cmGeneratedFileStream::cmGeneratedFileStream(Encoding encoding)
 cmGeneratedFileStream::cmGeneratedFileStream(std::string const& name,
                                              bool quiet, Encoding encoding)
   : cmGeneratedFileStreamBase(name)
-  , Stream(TempName.c_str())
+  , Stream(this->TempName.c_str())
 {
   // Check if the file opened.
   if (!*this && !quiet) {
@@ -37,7 +37,7 @@ cmGeneratedFileStream::cmGeneratedFileStream(std::string const& name,
   }
 #ifndef CMAKE_BOOTSTRAP
   if (encoding != codecvt::None) {
-    imbue(std::locale(getloc(), new codecvt(encoding)));
+    this->imbue(std::locale(this->getloc(), new codecvt(encoding)));
   }
 #else
   static_cast<void>(encoding);
diff --git a/Source/cmGeneratorExpressionDAGChecker.cxx b/Source/cmGeneratorExpressionDAGChecker.cxx
index e223f15453..a1fce552fe 100644
--- a/Source/cmGeneratorExpressionDAGChecker.cxx
+++ b/Source/cmGeneratorExpressionDAGChecker.cxx
@@ -28,7 +28,7 @@ cmGeneratorExpressionDAGChecker::cmGeneratorExpressionDAGChecker(
   , Backtrace(std::move(backtrace))
   , TransitivePropertiesOnly(false)
 {
-  Initialize();
+  this->Initialize();
 }
 
 cmGeneratorExpressionDAGChecker::cmGeneratorExpressionDAGChecker(
@@ -42,7 +42,7 @@ cmGeneratorExpressionDAGChecker::cmGeneratorExpressionDAGChecker(
   , Backtrace()
   , TransitivePropertiesOnly(false)
 {
-  Initialize();
+  this->Initialize();
 }
 
 void cmGeneratorExpressionDAGChecker::Initialize()
@@ -52,7 +52,7 @@ void cmGeneratorExpressionDAGChecker::Initialize()
 
 #define TEST_TRANSITIVE_PROPERTY_METHOD(METHOD) top->METHOD() ||
 
-  if (CheckResult == DAG &&
+  if (this->CheckResult == DAG &&
       (CM_FOR_EACH_TRANSITIVE_PROPERTY_METHOD(
         TEST_TRANSITIVE_PROPERTY_METHOD) false)) // NOLINT(*)
 #undef TEST_TRANSITIVE_PROPERTY_METHOD
diff --git a/Source/cmGeneratorExpressionEvaluationFile.cxx b/Source/cmGeneratorExpressionEvaluationFile.cxx
index af129d3ca2..ec44df3041 100644
--- a/Source/cmGeneratorExpressionEvaluationFile.cxx
+++ b/Source/cmGeneratorExpressionEvaluationFile.cxx
@@ -39,7 +39,7 @@ void cmGeneratorExpressionEvaluationFile::Generate(
   std::map<std::string, std::string>& outputFiles, mode_t perm)
 {
   std::string rawCondition = this->Condition->GetInput();
-  cmGeneratorTarget* target = lg->FindGeneratorTargetToUse(Target);
+  cmGeneratorTarget* target = lg->FindGeneratorTargetToUse(this->Target);
   if (!rawCondition.empty()) {
     std::string condResult =
       this->Condition->Evaluate(lg, config, target, nullptr, nullptr, lang);
@@ -95,7 +95,7 @@ void cmGeneratorExpressionEvaluationFile::CreateOutputFile(
 {
   std::vector<std::string> enabledLanguages;
   cmGlobalGenerator* gg = lg->GetGlobalGenerator();
-  cmGeneratorTarget* target = lg->FindGeneratorTargetToUse(Target);
+  cmGeneratorTarget* target = lg->FindGeneratorTargetToUse(this->Target);
   gg->GetEnabledLanguages(enabledLanguages);
 
   for (std::string const& le : enabledLanguages) {
diff --git a/Source/cmGeneratorExpressionLexer.cxx b/Source/cmGeneratorExpressionLexer.cxx
index a7f090ac7e..b8c38c005e 100644
--- a/Source/cmGeneratorExpressionLexer.cxx
+++ b/Source/cmGeneratorExpressionLexer.cxx
@@ -35,14 +35,14 @@ std::vector<cmGeneratorExpressionToken> cmGeneratorExpressionLexer::Tokenize(
                               2);
           upto = c + 2;
           ++c;
-          SawBeginExpression = true;
+          this->SawBeginExpression = true;
         }
         break;
       case '>':
         InsertText(upto, c, result);
         result.emplace_back(cmGeneratorExpressionToken::EndExpression, c, 1);
         upto = c + 1;
-        SawGeneratorExpression = SawBeginExpression;
+        this->SawGeneratorExpression = this->SawBeginExpression;
         break;
       case ':':
         InsertText(upto, c, result);
diff --git a/Source/cmGeneratorExpressionParser.cxx b/Source/cmGeneratorExpressionParser.cxx
index c2c9ef7230..794c1a1fa0 100644
--- a/Source/cmGeneratorExpressionParser.cxx
+++ b/Source/cmGeneratorExpressionParser.cxx
@@ -22,7 +22,7 @@ cmGeneratorExpressionParser::cmGeneratorExpressionParser(
 void cmGeneratorExpressionParser::Parse(
   cmGeneratorExpressionEvaluatorVector& result)
 {
-  it = this->Tokens.begin();
+  this->it = this->Tokens.begin();
 
   while (this->it != this->Tokens.end()) {
     this->ParseContent(result);
diff --git a/Source/cmGeneratorTarget.cxx b/Source/cmGeneratorTarget.cxx
index e2943d6aec..17d211e627 100644
--- a/Source/cmGeneratorTarget.cxx
+++ b/Source/cmGeneratorTarget.cxx
@@ -557,7 +557,7 @@ std::string cmGeneratorTarget::GetFilePostfix(const std::string& config) const
 
     // Frameworks created by multi config generators can have a special
     // framework postfix.
-    frameworkPostfix = GetFrameworkMultiConfigPostfix(config);
+    frameworkPostfix = this->GetFrameworkMultiConfigPostfix(config);
     if (!frameworkPostfix.empty()) {
       postfix = &frameworkPostfix;
     }
@@ -576,7 +576,7 @@ std::string cmGeneratorTarget::GetFrameworkMultiConfigPostfix(
 
     if (!this->IsImported() && postfix &&
         (this->IsFrameworkOnApple() &&
-         !GetGlobalGenerator()->IsMultiConfig())) {
+         !this->GetGlobalGenerator()->IsMultiConfig())) {
       postfix = nullptr;
     }
   }
@@ -2503,7 +2503,7 @@ public:
 
   bool GetHadLinkLanguageSensitiveCondition() const
   {
-    return HadLinkLanguageSensitiveCondition;
+    return this->HadLinkLanguageSensitiveCondition;
   }
 
 private:
@@ -3278,7 +3278,7 @@ void cmGeneratorTarget::AddCUDAArchitectureFlags(std::string& flags) const
       flags += " --cuda-gpu-arch=sm_" + architecture.name;
 
       if (!architecture.real) {
-        Makefile->IssueMessage(
+        this->Makefile->IssueMessage(
           MessageType::WARNING,
           "Clang doesn't support disabling CUDA real code generation.");
       }
@@ -4968,7 +4968,7 @@ void cmGeneratorTarget::GetFullNameInternal(
   // the base, because the suffix ends up being used in Xcode's
   // EXECUTABLE_SUFFIX attribute.
   if (this->IsFrameworkOnApple() &&
-      GetGlobalGenerator()->GetName() == "Xcode") {
+      this->GetGlobalGenerator()->GetName() == "Xcode") {
     targetSuffix = &configPostfix;
   } else {
     outBase += configPostfix;
diff --git a/Source/cmGeneratorTarget.h b/Source/cmGeneratorTarget.h
index 51369c2d47..8fe70abfc1 100644
--- a/Source/cmGeneratorTarget.h
+++ b/Source/cmGeneratorTarget.h
@@ -585,7 +585,8 @@ public:
     std::string PdbDir;
     bool empty() const
     {
-      return OutDir.empty() && ImpDir.empty() && PdbDir.empty();
+      return this->OutDir.empty() && this->ImpDir.empty() &&
+        this->PdbDir.empty();
     }
   };
 
diff --git a/Source/cmGhsMultiTargetGenerator.cxx b/Source/cmGhsMultiTargetGenerator.cxx
index aabe43c906..a7658f2b4e 100644
--- a/Source/cmGhsMultiTargetGenerator.cxx
+++ b/Source/cmGhsMultiTargetGenerator.cxx
@@ -62,7 +62,7 @@ void cmGhsMultiTargetGenerator::Generate()
       // Get the name of the executable to generate.
       this->TargetNameReal =
         this->GeneratorTarget->GetExecutableNames(this->ConfigName).Real;
-      if (cmGhsMultiTargetGenerator::DetermineIfIntegrityApp()) {
+      if (this->cmGhsMultiTargetGenerator::DetermineIfIntegrityApp()) {
         this->TagType = GhsMultiGpj::INTERGRITY_APPLICATION;
       } else {
         this->TagType = GhsMultiGpj::PROGRAM;
@@ -631,7 +631,7 @@ void cmGhsMultiTargetGenerator::WriteSources(std::ostream& fout_proj)
       }
     } else {
       std::vector<cmSourceFile const*> customCommands;
-      if (ComputeCustomCommandOrder(customCommands)) {
+      if (this->ComputeCustomCommandOrder(customCommands)) {
         std::string message = "The custom commands for target [" +
           this->GeneratorTarget->GetName() + "] had a cycle.\n";
         cmSystemTools::Error(message);
@@ -745,7 +745,7 @@ bool cmGhsMultiTargetGenerator::ComputeCustomCommandOrder(
   this->GeneratorTarget->GetCustomCommands(customCommands, this->ConfigName);
 
   for (cmSourceFile const* si : customCommands) {
-    bool r = VisitCustomCommand(temp, perm, order, si);
+    bool r = this->VisitCustomCommand(temp, perm, order, si);
     if (r) {
       return r;
     }
diff --git a/Source/cmGlobalGenerator.h b/Source/cmGlobalGenerator.h
index 69373bd81d..86fb22861d 100644
--- a/Source/cmGlobalGenerator.h
+++ b/Source/cmGlobalGenerator.h
@@ -69,17 +69,17 @@ struct GeneratedMakeCommand
   void Add(T&&... args)
   {
     // iterate the args and append each one
-    AppendStrs(PrimaryCommand, std::forward<T>(args)...);
+    AppendStrs(this->PrimaryCommand, std::forward<T>(args)...);
   }
 
   // Add each value in the iterators as a separate element to the vector
   void Add(std::vector<std::string>::const_iterator start,
            std::vector<std::string>::const_iterator end)
   {
-    cm::append(PrimaryCommand, start, end);
+    cm::append(this->PrimaryCommand, start, end);
   }
 
-  std::string Printable() const { return cmJoin(PrimaryCommand, " "); }
+  std::string Printable() const { return cmJoin(this->PrimaryCommand, " "); }
 
   std::vector<std::string> PrimaryCommand;
   bool RequiresOutputForward = false;
@@ -501,7 +501,7 @@ public:
     cmSourceFile* sf) const;
 
 #if !defined(CMAKE_BOOTSTRAP)
-  cmFileLockPool& GetFileLockPool() { return FileLockPool; }
+  cmFileLockPool& GetFileLockPool() { return this->FileLockPool; }
 #endif
 
   bool GetConfigureDoneCMP0026() const
diff --git a/Source/cmGlobalGhsMultiGenerator.cxx b/Source/cmGlobalGhsMultiGenerator.cxx
index 33bf830e01..0ddfe77593 100644
--- a/Source/cmGlobalGhsMultiGenerator.cxx
+++ b/Source/cmGlobalGhsMultiGenerator.cxx
@@ -366,7 +366,7 @@ void cmGlobalGhsMultiGenerator::WriteSubProjects(std::ostream& fout,
         target->GetType() == cmStateEnums::MODULE_LIBRARY ||
         target->GetType() == cmStateEnums::SHARED_LIBRARY ||
         (target->GetType() == cmStateEnums::GLOBAL_TARGET &&
-         target->GetName() != GetInstallTargetName())) {
+         target->GetName() != this->GetInstallTargetName())) {
       continue;
     }
     fout << "CMakeFiles/" << target->GetName() + ".tgt" + FILE_EXTENSION
@@ -415,7 +415,7 @@ void cmGlobalGhsMultiGenerator::WriteTargets(cmLocalGenerator* root)
         target->GetType() == cmStateEnums::MODULE_LIBRARY ||
         target->GetType() == cmStateEnums::SHARED_LIBRARY ||
         (target->GetType() == cmStateEnums::GLOBAL_TARGET &&
-         target->GetName() != GetInstallTargetName())) {
+         target->GetName() != this->GetInstallTargetName())) {
       continue;
     }
 
@@ -427,13 +427,13 @@ void cmGlobalGhsMultiGenerator::WriteTargets(cmLocalGenerator* root)
     this->WriteFileHeader(fbld);
     GhsMultiGpj::WriteGpjTag(GhsMultiGpj::PROJECT, fbld);
     std::vector<cmGeneratorTarget const*> build;
-    if (ComputeTargetBuildOrder(target, build)) {
+    if (this->ComputeTargetBuildOrder(target, build)) {
       cmSystemTools::Error(
         cmStrCat("The inter-target dependency graph for target [",
                  target->GetName(), "] had a cycle.\n"));
     } else {
       for (auto& tgt : build) {
-        WriteProjectLine(fbld, tgt, root, rootBinaryDir);
+        this->WriteProjectLine(fbld, tgt, root, rootBinaryDir);
       }
     }
     fbld.Close();
@@ -471,12 +471,12 @@ void cmGlobalGhsMultiGenerator::WriteAllTarget(
     if (!t->IsInBuildSystem()) {
       continue;
     }
-    if (!IsExcluded(t->GetLocalGenerator(), t)) {
+    if (!this->IsExcluded(t->GetLocalGenerator(), t)) {
       defaultTargets.push_back(t);
     }
   }
   std::vector<cmGeneratorTarget const*> build;
-  if (ComputeTargetBuildOrder(defaultTargets, build)) {
+  if (this->ComputeTargetBuildOrder(defaultTargets, build)) {
     std::string message = "The inter-target dependency graph for project [" +
       root->GetProjectName() + "] had a cycle.\n";
     cmSystemTools::Error(message);
@@ -694,7 +694,7 @@ bool cmGlobalGhsMultiGenerator::ComputeTargetBuildOrder(
   cmGeneratorTarget const* tgt, std::vector<cmGeneratorTarget const*>& build)
 {
   std::vector<cmGeneratorTarget const*> t{ tgt };
-  return ComputeTargetBuildOrder(t, build);
+  return this->ComputeTargetBuildOrder(t, build);
 }
 
 bool cmGlobalGhsMultiGenerator::ComputeTargetBuildOrder(
@@ -705,7 +705,7 @@ bool cmGlobalGhsMultiGenerator::ComputeTargetBuildOrder(
   std::set<cmGeneratorTarget const*> perm;
 
   for (auto const ti : tgt) {
-    bool r = VisitTarget(temp, perm, build, ti);
+    bool r = this->VisitTarget(temp, perm, build, ti);
     if (r) {
       return r;
     }
diff --git a/Source/cmGlobalNinjaGenerator.cxx b/Source/cmGlobalNinjaGenerator.cxx
index a098f81e11..a95ab25a95 100644
--- a/Source/cmGlobalNinjaGenerator.cxx
+++ b/Source/cmGlobalNinjaGenerator.cxx
@@ -182,7 +182,7 @@ std::string cmGlobalNinjaGenerator::EncodePath(const std::string& path)
   else
     std::replace(result.begin(), result.end(), '/', '\\');
 #endif
-  result = EncodeLiteral(result);
+  result = this->EncodeLiteral(result);
   cmSystemTools::ReplaceString(result, " ", "$ ");
   cmSystemTools::ReplaceString(result, ":", "$:");
   return result;
@@ -214,7 +214,7 @@ void cmGlobalNinjaGenerator::WriteBuild(std::ostream& os,
   {
     // Write explicit outputs
     for (std::string const& output : build.Outputs) {
-      buildStr += cmStrCat(' ', EncodePath(output));
+      buildStr += cmStrCat(' ', this->EncodePath(output));
       if (this->ComputingUnknownDependencies) {
         this->CombinedBuildOutputs.insert(output);
       }
@@ -223,7 +223,7 @@ void cmGlobalNinjaGenerator::WriteBuild(std::ostream& os,
     if (!build.ImplicitOuts.empty()) {
       buildStr += " |";
       for (std::string const& implicitOut : build.ImplicitOuts) {
-        buildStr += cmStrCat(' ', EncodePath(implicitOut));
+        buildStr += cmStrCat(' ', this->EncodePath(implicitOut));
       }
     }
     buildStr += ':';
@@ -238,14 +238,14 @@ void cmGlobalNinjaGenerator::WriteBuild(std::ostream& os,
 
     // Write explicit dependencies.
     for (std::string const& explicitDep : build.ExplicitDeps) {
-      arguments += cmStrCat(' ', EncodePath(explicitDep));
+      arguments += cmStrCat(' ', this->EncodePath(explicitDep));
     }
 
     // Write implicit dependencies.
     if (!build.ImplicitDeps.empty()) {
       arguments += " |";
       for (std::string const& implicitDep : build.ImplicitDeps) {
-        arguments += cmStrCat(' ', EncodePath(implicitDep));
+        arguments += cmStrCat(' ', this->EncodePath(implicitDep));
       }
     }
 
@@ -253,7 +253,7 @@ void cmGlobalNinjaGenerator::WriteBuild(std::ostream& os,
     if (!build.OrderOnlyDeps.empty()) {
       arguments += " ||";
       for (std::string const& orderOnlyDep : build.OrderOnlyDeps) {
-        arguments += cmStrCat(' ', EncodePath(orderOnlyDep));
+        arguments += cmStrCat(' ', this->EncodePath(orderOnlyDep));
       }
     }
 
@@ -331,11 +331,11 @@ void cmGlobalNinjaGenerator::WriteCustomCommandBuild(
 #endif
       vars["COMMAND"] = std::move(cmd);
     }
-    vars["DESC"] = EncodeLiteral(description);
+    vars["DESC"] = this->EncodeLiteral(description);
     if (restat) {
       vars["restat"] = "1";
     }
-    if (uses_terminal && SupportsConsolePool()) {
+    if (uses_terminal && this->SupportsConsolePool()) {
       vars["pool"] = "console";
     } else if (!job_pool.empty()) {
       vars["pool"] = job_pool;
@@ -362,7 +362,7 @@ void cmGlobalNinjaGenerator::WriteCustomCommandBuild(
 void cmGlobalNinjaGenerator::AddMacOSXContentRule()
 {
   cmNinjaRule rule("COPY_OSX_CONTENT");
-  rule.Command = cmStrCat(CMakeCmd(), " -E copy $in $out");
+  rule.Command = cmStrCat(this->CMakeCmd(), " -E copy $in $out");
   rule.Description = "Copying OS X Content $out";
   rule.Comment = "Rule for copying OS X bundle content file.";
   this->AddRule(rule);
@@ -1032,8 +1032,8 @@ static void EnsureTrailingSlash(std::string& path)
 std::string const& cmGlobalNinjaGenerator::ConvertToNinjaPath(
   const std::string& path) const
 {
-  auto const f = ConvertToNinjaPathCache.find(path);
-  if (f != ConvertToNinjaPathCache.end()) {
+  auto const f = this->ConvertToNinjaPathCache.find(path);
+  if (f != this->ConvertToNinjaPathCache.end()) {
     return f->second;
   }
 
@@ -1045,7 +1045,7 @@ std::string const& cmGlobalNinjaGenerator::ConvertToNinjaPath(
 #ifdef _WIN32
   std::replace(convPath.begin(), convPath.end(), '/', '\\');
 #endif
-  return ConvertToNinjaPathCache.emplace(path, std::move(convPath))
+  return this->ConvertToNinjaPathCache.emplace(path, std::move(convPath))
     .first->second;
 }
 
@@ -1117,12 +1117,13 @@ void cmGlobalNinjaGenerator::WriteAssumedSourceDependencies()
     cmNinjaDeps orderOnlyDeps;
     std::copy(asd.second.begin(), asd.second.end(),
               std::back_inserter(orderOnlyDeps));
-    WriteCustomCommandBuild(/*command=*/"", /*description=*/"",
-                            "Assume dependencies for generated source file.",
-                            /*depfile*/ "", /*job_pool*/ "",
-                            /*uses_terminal*/ false,
-                            /*restat*/ true, cmNinjaDeps(1, asd.first), "",
-                            cmNinjaDeps(), orderOnlyDeps);
+    this->WriteCustomCommandBuild(
+      /*command=*/"", /*description=*/"",
+      "Assume dependencies for generated source file.",
+      /*depfile*/ "", /*job_pool*/ "",
+      /*uses_terminal*/ false,
+      /*restat*/ true, cmNinjaDeps(1, asd.first), "", cmNinjaDeps(),
+      orderOnlyDeps);
   }
 }
 
@@ -1147,7 +1148,7 @@ void cmGlobalNinjaGenerator::AppendTargetOutputs(
     case cmStateEnums::STATIC_LIBRARY:
     case cmStateEnums::MODULE_LIBRARY: {
       if (depends == DependOnTargetOrdering) {
-        outputs.push_back(OrderDependsTargetForTarget(target, config));
+        outputs.push_back(this->OrderDependsTargetForTarget(target, config));
         break;
       }
     }
@@ -1159,7 +1160,7 @@ void cmGlobalNinjaGenerator::AppendTargetOutputs(
     }
     case cmStateEnums::OBJECT_LIBRARY: {
       if (depends == DependOnTargetOrdering) {
-        outputs.push_back(OrderDependsTargetForTarget(target, config));
+        outputs.push_back(this->OrderDependsTargetForTarget(target, config));
         break;
       }
     }
@@ -1476,7 +1477,7 @@ void cmGlobalNinjaGenerator::WriteFolderTargets(std::ostream& os)
       build.Outputs.front() = this->BuildAlias(buildDirAllTarget, config);
       configDeps.emplace_back(build.Outputs.front());
       for (DirectoryTarget::Target const& t : dt.Targets) {
-        if (!IsExcludedFromAllInConfig(t, config)) {
+        if (!this->IsExcludedFromAllInConfig(t, config)) {
           this->AppendTargetOutputs(t.GT, build.ExplicitDeps, config,
                                     DependOnTargetArtifact);
         }
@@ -1689,7 +1690,7 @@ void cmGlobalNinjaGenerator::WriteTargetRebuildManifest(std::ostream& os)
   {
     cmNinjaRule rule("RERUN_CMAKE");
     rule.Command =
-      cmStrCat(CMakeCmd(), " --regenerate-during-build -S",
+      cmStrCat(this->CMakeCmd(), " --regenerate-during-build -S",
                lg->ConvertToOutputFormat(lg->GetSourceDirectory(),
                                          cmOutputConverter::SHELL),
                " -B",
@@ -1714,7 +1715,7 @@ void cmGlobalNinjaGenerator::WriteTargetRebuildManifest(std::ostream& os)
 
   // Use 'console' pool to get non buffered output of the CMake re-run call
   // Available since Ninja 1.5
-  if (SupportsConsolePool()) {
+  if (this->SupportsConsolePool()) {
     reBuild.Variables["pool"] = "console";
   }
 
@@ -1723,7 +1724,7 @@ void cmGlobalNinjaGenerator::WriteTargetRebuildManifest(std::ostream& os)
     {
       cmNinjaRule rule("VERIFY_GLOBS");
       rule.Command =
-        cmStrCat(CMakeCmd(), " -P ",
+        cmStrCat(this->CMakeCmd(), " -P ",
                  lg->ConvertToOutputFormat(cm->GetGlobVerifyScript(),
                                            cmOutputConverter::SHELL));
       rule.Description = "Re-checking globbed directories...";
@@ -1784,8 +1785,8 @@ void cmGlobalNinjaGenerator::WriteTargetRebuildManifest(std::ostream& os)
     build.Comment = "A missing CMake input file is not an error.";
     std::set_difference(std::make_move_iterator(reBuild.ImplicitDeps.begin()),
                         std::make_move_iterator(reBuild.ImplicitDeps.end()),
-                        CustomCommandOutputs.begin(),
-                        CustomCommandOutputs.end(),
+                        this->CustomCommandOutputs.begin(),
+                        this->CustomCommandOutputs.end(),
                         std::back_inserter(build.Outputs));
     this->WriteBuild(os, build);
   }
@@ -1869,7 +1870,8 @@ bool cmGlobalNinjaGenerator::WriteTargetCleanAdditional(std::ostream& os)
         fout << "  file(REMOVE_RECURSE\n";
         for (std::string const& acf : it->second.AdditionalCleanFiles) {
           fout << "  "
-               << cmOutputConverter::EscapeForCMake(ConvertToNinjaPath(acf))
+               << cmOutputConverter::EscapeForCMake(
+                    this->ConvertToNinjaPath(acf))
                << '\n';
         }
         fout << "  )\n";
@@ -1884,7 +1886,7 @@ bool cmGlobalNinjaGenerator::WriteTargetCleanAdditional(std::ostream& os)
   {
     cmNinjaRule rule("CLEAN_ADDITIONAL");
     rule.Command = cmStrCat(
-      CMakeCmd(), " -DCONFIG=$CONFIG -P ",
+      this->CMakeCmd(), " -DCONFIG=$CONFIG -P ",
       lgr->ConvertToOutputFormat(this->NinjaOutputPath(cleanScriptRel),
                                  cmOutputConverter::SHELL));
     rule.Description = "Cleaning additional files...";
@@ -1901,13 +1903,13 @@ bool cmGlobalNinjaGenerator::WriteTargetCleanAdditional(std::ostream& os)
       build.Outputs.front() = this->BuildAlias(
         this->NinjaOutputPath(this->GetAdditionalCleanTargetName()), config);
       build.Variables["CONFIG"] = config;
-      WriteBuild(os, build);
+      this->WriteBuild(os, build);
     }
     if (this->IsMultiConfig()) {
       build.Outputs.front() =
         this->NinjaOutputPath(this->GetAdditionalCleanTargetName());
       build.Variables["CONFIG"] = "";
-      WriteBuild(os, build);
+      this->WriteBuild(os, build);
     }
   }
   // Return success
@@ -1917,13 +1919,13 @@ bool cmGlobalNinjaGenerator::WriteTargetCleanAdditional(std::ostream& os)
 void cmGlobalNinjaGenerator::WriteTargetClean(std::ostream& os)
 {
   // -- Additional clean target
-  bool additionalFiles = WriteTargetCleanAdditional(os);
+  bool additionalFiles = this->WriteTargetCleanAdditional(os);
 
   // -- Default clean target
   // Write rule
   {
     cmNinjaRule rule("CLEAN");
-    rule.Command = cmStrCat(NinjaCmd(), " $FILE_ARG -t clean $TARGETS");
+    rule.Command = cmStrCat(this->NinjaCmd(), " $FILE_ARG -t clean $TARGETS");
     rule.Description = "Cleaning all built files...";
     rule.Comment = "Rule for cleaning all built files.";
     WriteRule(*this->RulesFileStream, rule);
@@ -2024,13 +2026,13 @@ void cmGlobalNinjaGenerator::WriteTargetClean(std::ostream& os)
     build.Outputs.emplace_back(
       this->ConvertToNinjaPath(GetByproductsForCleanTargetName()));
     build.ExplicitDeps = this->ByproductsForCleanTarget;
-    WriteBuild(os, build);
+    this->WriteBuild(os, build);
 
     for (auto const& config : configs) {
       build.Outputs.front() = this->BuildAlias(
         this->ConvertToNinjaPath(GetByproductsForCleanTargetName()), config);
       build.ExplicitDeps = this->Configs[config].ByproductsForCleanTarget;
-      WriteBuild(os, build);
+      this->WriteBuild(os, build);
     }
   }
 }
@@ -2039,7 +2041,7 @@ void cmGlobalNinjaGenerator::WriteTargetHelp(std::ostream& os)
 {
   {
     cmNinjaRule rule("HELP");
-    rule.Command = cmStrCat(NinjaCmd(), " -t targets");
+    rule.Command = cmStrCat(this->NinjaCmd(), " -t targets");
     rule.Description = "All primary targets available:";
     rule.Comment = "Rule for printing all primary targets available.";
     WriteRule(*this->RulesFileStream, rule);
@@ -2048,7 +2050,7 @@ void cmGlobalNinjaGenerator::WriteTargetHelp(std::ostream& os)
     cmNinjaBuild build("HELP");
     build.Comment = "Print all primary targets available.";
     build.Outputs.push_back(this->NinjaOutputPath("help"));
-    WriteBuild(os, build);
+    this->WriteBuild(os, build);
   }
 }
 
diff --git a/Source/cmGlobalNinjaGenerator.h b/Source/cmGlobalNinjaGenerator.h
index 5e9defeebb..0e94678e99 100644
--- a/Source/cmGlobalNinjaGenerator.h
+++ b/Source/cmGlobalNinjaGenerator.h
@@ -150,7 +150,7 @@ public:
   static void WriteDefault(std::ostream& os, const cmNinjaDeps& targets,
                            const std::string& comment = "");
 
-  bool IsGCCOnWindows() const { return UsingGCCOnWindows; }
+  bool IsGCCOnWindows() const { return this->UsingGCCOnWindows; }
 
 public:
   cmGlobalNinjaGenerator(cmake* cm);
@@ -354,7 +354,10 @@ public:
     outputs.push_back(this->NinjaOutputPath(NINJA_BUILD_FILE));
   }
 
-  int GetRuleCmdLength(const std::string& name) { return RuleCmdLength[name]; }
+  int GetRuleCmdLength(const std::string& name)
+  {
+    return this->RuleCmdLength[name];
+  }
 
   void AddTargetAlias(const std::string& alias, cmGeneratorTarget* target,
                       const std::string& config);
diff --git a/Source/cmGlobalUnixMakefileGenerator3.cxx b/Source/cmGlobalUnixMakefileGenerator3.cxx
index 11e2cd6e28..97384cd5a8 100644
--- a/Source/cmGlobalUnixMakefileGenerator3.cxx
+++ b/Source/cmGlobalUnixMakefileGenerator3.cxx
@@ -838,7 +838,7 @@ void cmGlobalUnixMakefileGenerator3::InitializeProgressMarks()
     for (const auto& gt : lg->GetGeneratorTargets()) {
       cmLocalGenerator* tlg = gt->GetLocalGenerator();
 
-      if (!gt->IsInBuildSystem() || IsExcluded(lg.get(), gt.get())) {
+      if (!gt->IsInBuildSystem() || this->IsExcluded(lg.get(), gt.get())) {
         continue;
       }
 
diff --git a/Source/cmGraphVizWriter.cxx b/Source/cmGraphVizWriter.cxx
index cf4ba93c54..92ffe2969a 100644
--- a/Source/cmGraphVizWriter.cxx
+++ b/Source/cmGraphVizWriter.cxx
@@ -131,8 +131,8 @@ cmGraphVizWriter::~cmGraphVizWriter()
 
 void cmGraphVizWriter::VisitGraph(std::string const&)
 {
-  this->WriteHeader(GlobalFileStream, this->GraphName);
-  this->WriteLegend(GlobalFileStream);
+  this->WriteHeader(this->GlobalFileStream, this->GraphName);
+  this->WriteLegend(this->GlobalFileStream);
 }
 
 void cmGraphVizWriter::OnItem(cmLinkItem const& item)
@@ -141,8 +141,9 @@ void cmGraphVizWriter::OnItem(cmLinkItem const& item)
     return;
   }
 
-  NodeNames[item.AsStr()] = cmStrCat(GraphNodePrefix, NextNodeId);
-  ++NextNodeId;
+  this->NodeNames[item.AsStr()] =
+    cmStrCat(this->GraphNodePrefix, this->NextNodeId);
+  ++this->NextNodeId;
 
   this->WriteNode(this->GlobalFileStream, item);
 }
@@ -191,12 +192,13 @@ void cmGraphVizWriter::VisitLink(cmLinkItem const& depender,
   this->WriteConnection(this->GlobalFileStream, depender, dependee, scopeType);
 
   if (this->GeneratePerTarget) {
-    PerTargetConnections[depender].emplace_back(depender, dependee, scopeType);
+    this->PerTargetConnections[depender].emplace_back(depender, dependee,
+                                                      scopeType);
   }
 
   if (this->GenerateDependers) {
-    TargetDependersConnections[dependee].emplace_back(dependee, depender,
-                                                      scopeType);
+    this->TargetDependersConnections[dependee].emplace_back(dependee, depender,
+                                                            scopeType);
   }
 }
 
@@ -307,12 +309,12 @@ void cmGraphVizWriter::Write()
   }
 
   if (this->GeneratePerTarget) {
-    WritePerTargetConnections<DependeesDir>(PerTargetConnections);
+    this->WritePerTargetConnections<DependeesDir>(this->PerTargetConnections);
   }
 
   if (this->GenerateDependers) {
-    WritePerTargetConnections<DependersDir>(TargetDependersConnections,
-                                            ".dependers");
+    this->WritePerTargetConnections<DependersDir>(
+      this->TargetDependersConnections, ".dependers");
   }
 }
 
@@ -336,7 +338,8 @@ void cmGraphVizWriter::FindAllConnections(const ConnectionsMap& connectionMap,
     bool const visited = visitedItems.find(dstItem) != visitedItems.cend();
     if (!visited) {
       visitedItems.insert(dstItem);
-      FindAllConnections(connectionMap, dstItem, extendedCons, visitedItems);
+      this->FindAllConnections(connectionMap, dstItem, extendedCons,
+                               visitedItems);
     }
   }
 }
@@ -346,7 +349,8 @@ void cmGraphVizWriter::FindAllConnections(const ConnectionsMap& connectionMap,
                                           Connections& extendedCons)
 {
   std::set<cmLinkItem> visitedItems = { rootItem };
-  FindAllConnections(connectionMap, rootItem, extendedCons, visitedItems);
+  this->FindAllConnections(connectionMap, rootItem, extendedCons,
+                           visitedItems);
 }
 
 template <typename DirFunc>
@@ -358,7 +362,7 @@ void cmGraphVizWriter::WritePerTargetConnections(
   for (auto const& conPerTarget : connections) {
     const cmLinkItem& rootItem = conPerTarget.first;
     Connections& extendedCons = extendedConnections[conPerTarget.first];
-    FindAllConnections(connections, rootItem, extendedCons);
+    this->FindAllConnections(connections, rootItem, extendedCons);
   }
 
   for (auto const& conPerTarget : extendedConnections) {
@@ -451,7 +455,7 @@ void cmGraphVizWriter::WriteNode(cmGeneratedFileStream& fs,
   auto const& itemName = item.AsStr();
   auto const& nodeName = this->NodeNames[itemName];
 
-  auto const itemNameWithAliases = ItemNameWithAliases(itemName);
+  auto const itemNameWithAliases = this->ItemNameWithAliases(itemName);
   auto const escapedLabel = EscapeForDotFile(itemNameWithAliases);
 
   fs << "    \"" << nodeName << "\" [ label = \"" << escapedLabel
diff --git a/Source/cmInstallDirectoryGenerator.cxx b/Source/cmInstallDirectoryGenerator.cxx
index 175e7cf0be..0b45f28aac 100644
--- a/Source/cmInstallDirectoryGenerator.cxx
+++ b/Source/cmInstallDirectoryGenerator.cxx
@@ -27,7 +27,7 @@ cmInstallDirectoryGenerator::cmInstallDirectoryGenerator(
   , Optional(optional)
 {
   // We need per-config actions if destination have generator expressions.
-  if (cmGeneratorExpression::Find(Destination) != std::string::npos) {
+  if (cmGeneratorExpression::Find(this->Destination) != std::string::npos) {
     this->ActionsPerConfig = true;
   }
 
diff --git a/Source/cmInstallExportGenerator.cxx b/Source/cmInstallExportGenerator.cxx
index 6e3508c2d6..3683adae8b 100644
--- a/Source/cmInstallExportGenerator.cxx
+++ b/Source/cmInstallExportGenerator.cxx
@@ -122,10 +122,10 @@ size_t cmInstallExportGenerator::GetMaxConfigLength() const
 void cmInstallExportGenerator::GenerateScript(std::ostream& os)
 {
   // Skip empty sets.
-  if (ExportSet->GetTargetExports().empty()) {
+  if (this->ExportSet->GetTargetExports().empty()) {
     std::ostringstream e;
-    e << "INSTALL(EXPORT) given unknown export \"" << ExportSet->GetName()
-      << "\"";
+    e << "INSTALL(EXPORT) given unknown export \""
+      << this->ExportSet->GetName() << "\"";
     cmSystemTools::Error(e.str());
     return;
   }
diff --git a/Source/cmInstallFilesGenerator.cxx b/Source/cmInstallFilesGenerator.cxx
index ad2f84e024..c45000d467 100644
--- a/Source/cmInstallFilesGenerator.cxx
+++ b/Source/cmInstallFilesGenerator.cxx
@@ -26,7 +26,7 @@ cmInstallFilesGenerator::cmInstallFilesGenerator(
   , Optional(optional)
 {
   // We need per-config actions if the destination has generator expressions.
-  if (cmGeneratorExpression::Find(Destination) != std::string::npos) {
+  if (cmGeneratorExpression::Find(this->Destination) != std::string::npos) {
     this->ActionsPerConfig = true;
   }
 
diff --git a/Source/cmInstallScriptGenerator.cxx b/Source/cmInstallScriptGenerator.cxx
index 7cdf3b45be..ce2472d077 100644
--- a/Source/cmInstallScriptGenerator.cxx
+++ b/Source/cmInstallScriptGenerator.cxx
@@ -22,7 +22,7 @@ cmInstallScriptGenerator::cmInstallScriptGenerator(
   , AllowGenex(false)
 {
   // We need per-config actions if the script has generator expressions.
-  if (cmGeneratorExpression::Find(Script) != std::string::npos) {
+  if (cmGeneratorExpression::Find(this->Script) != std::string::npos) {
     this->ActionsPerConfig = true;
   }
 }
diff --git a/Source/cmLinkedTree.h b/Source/cmLinkedTree.h
index d70176dfca..616bf7e767 100644
--- a/Source/cmLinkedTree.h
+++ b/Source/cmLinkedTree.h
@@ -133,9 +133,9 @@ public:
     return iterator(const_cast<cmLinkedTree*>(this), 0);
   }
 
-  iterator Push(iterator it) { return Push_impl(it, T()); }
+  iterator Push(iterator it) { return this->Push_impl(it, T()); }
 
-  iterator Push(iterator it, T t) { return Push_impl(it, std::move(t)); }
+  iterator Push(iterator it, T t) { return this->Push_impl(it, std::move(t)); }
 
   bool IsLast(iterator it) { return it.Position == this->Data.size(); }
 
diff --git a/Source/cmListCommand.cxx b/Source/cmListCommand.cxx
index a2c14bd1a8..53c871b997 100644
--- a/Source/cmListCommand.cxx
+++ b/Source/cmListCommand.cxx
@@ -609,9 +609,9 @@ public:
 
   bool Validate(std::size_t count) override
   {
-    decltype(Indexes) indexes;
+    decltype(this->Indexes) indexes;
 
-    for (auto index : Indexes) {
+    for (auto index : this->Indexes) {
       indexes.push_back(this->NormalizeIndex(index, count));
     }
     this->Indexes = std::move(indexes);
@@ -750,7 +750,7 @@ bool HandleTransformCommand(std::vector<std::string> const& args,
     {
     }
 
-    operator const std::string&() const { return Name; }
+    operator const std::string&() const { return this->Name; }
 
     std::string Name;
     int Arity = 0;
@@ -1093,8 +1093,9 @@ protected:
 public:
   cmStringSorter(Compare compare, CaseSensitivity caseSensitivity,
                  Order desc = Order::ASCENDING)
-    : filters{ GetCompareFilter(compare), GetCaseFilter(caseSensitivity) }
-    , sortMethod(GetComparisonFunction(compare))
+    : filters{ this->GetCompareFilter(compare),
+               this->GetCaseFilter(caseSensitivity) }
+    , sortMethod(this->GetComparisonFunction(compare))
     , descending(desc == Order::DESCENDING)
   {
   }
@@ -1102,7 +1103,7 @@ public:
   std::string ApplyFilter(const std::string& argument)
   {
     std::string result = argument;
-    for (auto filter : filters) {
+    for (auto filter : this->filters) {
       if (filter != nullptr) {
         result = filter(result);
       }
@@ -1112,13 +1113,13 @@ public:
 
   bool operator()(const std::string& a, const std::string& b)
   {
-    std::string af = ApplyFilter(a);
-    std::string bf = ApplyFilter(b);
+    std::string af = this->ApplyFilter(a);
+    std::string bf = this->ApplyFilter(b);
     bool result;
-    if (descending) {
-      result = sortMethod(bf, af);
+    if (this->descending) {
+      result = this->sortMethod(bf, af);
     } else {
-      result = sortMethod(af, bf);
+      result = this->sortMethod(af, bf);
     }
     return result;
   }
@@ -1424,7 +1425,7 @@ public:
 
   bool operator()(const std::string& target)
   {
-    return regex.find(target) ^ includeMatches;
+    return this->regex.find(target) ^ this->includeMatches;
   }
 
 private:
diff --git a/Source/cmListFileCache.cxx b/Source/cmListFileCache.cxx
index 3658d119aa..36a1372132 100644
--- a/Source/cmListFileCache.cxx
+++ b/Source/cmListFileCache.cxx
@@ -105,7 +105,7 @@ bool cmListFileParser::ParseFile(const char* filename)
     return false;
   }
 
-  return Parse();
+  return this->Parse();
 }
 
 bool cmListFileParser::ParseString(const char* str,
@@ -118,7 +118,7 @@ bool cmListFileParser::ParseString(const char* str,
     return false;
   }
 
-  return Parse();
+  return this->Parse();
 }
 
 bool cmListFileParser::Parse()
diff --git a/Source/cmListFileCache.h b/Source/cmListFileCache.h
index ed45c0757c..98cb4a772c 100644
--- a/Source/cmListFileCache.h
+++ b/Source/cmListFileCache.h
@@ -249,7 +249,7 @@ public:
   BTs(T v = T(), cmListFileBacktrace bt = cmListFileBacktrace())
     : Value(std::move(v))
   {
-    Backtraces.emplace_back(std::move(bt));
+    this->Backtraces.emplace_back(std::move(bt));
   }
   T Value;
   std::vector<cmListFileBacktrace> Backtraces;
diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx
index b329e4b9ba..86eddc209f 100644
--- a/Source/cmLocalGenerator.cxx
+++ b/Source/cmLocalGenerator.cxx
@@ -2607,11 +2607,11 @@ void cmLocalGenerator::AddPchDependencies(cmGeneratorTarget* target)
                 }
 
                 if (editAndContinueDebugInfo || msvc2008OrLess) {
-                  CopyPchCompilePdb(config, target, *ReuseFrom, reuseTarget,
-                                    { ".pdb", ".idb" });
+                  this->CopyPchCompilePdb(config, target, *ReuseFrom,
+                                          reuseTarget, { ".pdb", ".idb" });
                 } else if (enableDebuggingInformation) {
-                  CopyPchCompilePdb(config, target, *ReuseFrom, reuseTarget,
-                                    { ".pdb" });
+                  this->CopyPchCompilePdb(config, target, *ReuseFrom,
+                                          reuseTarget, { ".pdb" });
                 }
               }
 
diff --git a/Source/cmLocalUnixMakefileGenerator3.cxx b/Source/cmLocalUnixMakefileGenerator3.cxx
index 358df9d339..df7952cf14 100644
--- a/Source/cmLocalUnixMakefileGenerator3.cxx
+++ b/Source/cmLocalUnixMakefileGenerator3.cxx
@@ -96,8 +96,8 @@ public:
 
     // If it's an absolute path, check if it starts with the source
     // directory:
-    return !(cmCMakePath(SourceDir).IsPrefix(path) ||
-             cmCMakePath(BinaryDir).IsPrefix(path));
+    return !(cmCMakePath(this->SourceDir).IsPrefix(path) ||
+             cmCMakePath(this->BinaryDir).IsPrefix(path));
   }
 
 private:
diff --git a/Source/cmMSVC60LinkLineComputer.cxx b/Source/cmMSVC60LinkLineComputer.cxx
index 74c94351c5..8cf37659db 100644
--- a/Source/cmMSVC60LinkLineComputer.cxx
+++ b/Source/cmMSVC60LinkLineComputer.cxx
@@ -36,5 +36,5 @@ std::string cmMSVC60LinkLineComputer::ConvertToLinkReference(
   }
 #endif
 
-  return cmLinkLineComputer::ConvertToLinkReference(lib);
+  return this->cmLinkLineComputer::ConvertToLinkReference(lib);
 }
diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx
index 9d37d61645..0faef153ec 100644
--- a/Source/cmMakefile.cxx
+++ b/Source/cmMakefile.cxx
@@ -978,7 +978,7 @@ struct BacktraceGuard
     this->Backtrace = std::move(current);
   }
 
-  ~BacktraceGuard() { this->Backtrace = std::move(Previous); }
+  ~BacktraceGuard() { this->Backtrace = std::move(this->Previous); }
 
 private:
   cmListFileBacktrace& Backtrace;
@@ -2438,7 +2438,7 @@ cmMakefile::AppleSDK cmMakefile::GetAppleSDKType() const
 
 bool cmMakefile::PlatformIsAppleEmbedded() const
 {
-  return GetAppleSDKType() != AppleSDK::MacOS;
+  return this->GetAppleSDKType() != AppleSDK::MacOS;
 }
 
 const char* cmMakefile::GetSONameFlag(const std::string& language) const
@@ -2449,7 +2449,7 @@ const char* cmMakefile::GetSONameFlag(const std::string& language) const
     name += language;
   }
   name += "_FLAG";
-  return cmToCStr(GetDefinition(name));
+  return cmToCStr(this->GetDefinition(name));
 }
 
 bool cmMakefile::CanIWriteThisFile(std::string const& fileName) const
@@ -2472,7 +2472,7 @@ const std::string& cmMakefile::GetRequiredDefinition(
   const std::string& name) const
 {
   static std::string const empty;
-  const std::string* def = GetDefinition(name);
+  const std::string* def = this->GetDefinition(name);
   if (!def) {
     cmSystemTools::Error("Error required internal CMake variable not "
                          "set, cmake may not be built correctly.\n"
@@ -2532,7 +2532,7 @@ cmProp cmMakefile::GetDefinition(const std::string& name) const
 const std::string& cmMakefile::GetSafeDefinition(const std::string& name) const
 {
   static std::string const empty;
-  const std::string* def = GetDefinition(name);
+  const std::string* def = this->GetDefinition(name);
   if (!def) {
     return empty;
   }
@@ -2598,24 +2598,24 @@ const std::string& cmMakefile::ExpandVariablesInString(
       // Suppress variable watches to avoid calling hooks twice. Suppress new
       // dereferences since the OLD behavior is still what is actually used.
       this->SuppressSideEffects = true;
-      newError = ExpandVariablesInStringNew(newErrorstr, newResult,
-                                            escapeQuotes, noEscapes, atOnly,
-                                            filename, line, replaceAt);
+      newError = this->ExpandVariablesInStringNew(
+        newErrorstr, newResult, escapeQuotes, noEscapes, atOnly, filename,
+        line, replaceAt);
       this->SuppressSideEffects = false;
       CM_FALLTHROUGH;
     }
     case cmPolicies::OLD:
-      mtype =
-        ExpandVariablesInStringOld(errorstr, source, escapeQuotes, noEscapes,
-                                   atOnly, filename, line, removeEmpty, true);
+      mtype = this->ExpandVariablesInStringOld(errorstr, source, escapeQuotes,
+                                               noEscapes, atOnly, filename,
+                                               line, removeEmpty, true);
       break;
     case cmPolicies::REQUIRED_IF_USED:
     case cmPolicies::REQUIRED_ALWAYS:
     // Messaging here would be *very* verbose.
     case cmPolicies::NEW:
-      mtype =
-        ExpandVariablesInStringNew(errorstr, source, escapeQuotes, noEscapes,
-                                   atOnly, filename, line, replaceAt);
+      mtype = this->ExpandVariablesInStringNew(errorstr, source, escapeQuotes,
+                                               noEscapes, atOnly, filename,
+                                               line, replaceAt);
       break;
   }
 
diff --git a/Source/cmMakefile.h b/Source/cmMakefile.h
index 1617793b21..60b66a2fad 100644
--- a/Source/cmMakefile.h
+++ b/Source/cmMakefile.h
@@ -292,7 +292,7 @@ public:
                           const char* doc, cmStateEnums::CacheEntryType type,
                           bool force = false)
   {
-    AddCacheDefinition(name, value.c_str(), doc, type, force);
+    this->AddCacheDefinition(name, value.c_str(), doc, type, force);
   }
 
   /**
diff --git a/Source/cmMakefileTargetGenerator.cxx b/Source/cmMakefileTargetGenerator.cxx
index 70a0393276..0f91d6d6fb 100644
--- a/Source/cmMakefileTargetGenerator.cxx
+++ b/Source/cmMakefileTargetGenerator.cxx
@@ -71,7 +71,8 @@ cmMakefileTargetGenerator::cmMakefileTargetGenerator(cmGeneratorTarget* target)
       this->CMP0113New = true;
       break;
   }
-  MacOSXContentGenerator = cm::make_unique<MacOSXContentGeneratorType>(this);
+  this->MacOSXContentGenerator =
+    cm::make_unique<MacOSXContentGeneratorType>(this);
 }
 
 cmMakefileTargetGenerator::~cmMakefileTargetGenerator() = default;
diff --git a/Source/cmNewLineStyle.cxx b/Source/cmNewLineStyle.cxx
index a121332b2c..28baeb69d0 100644
--- a/Source/cmNewLineStyle.cxx
+++ b/Source/cmNewLineStyle.cxx
@@ -8,13 +8,13 @@ cmNewLineStyle::cmNewLineStyle() = default;
 
 bool cmNewLineStyle::IsValid() const
 {
-  return NewLineStyle != Invalid;
+  return this->NewLineStyle != Invalid;
 }
 
 bool cmNewLineStyle::ReadFromArguments(const std::vector<std::string>& args,
                                        std::string& errorString)
 {
-  NewLineStyle = Invalid;
+  this->NewLineStyle = Invalid;
 
   for (size_t i = 0; i < args.size(); i++) {
     if (args[i] == "NEWLINE_STYLE") {
@@ -22,11 +22,11 @@ bool cmNewLineStyle::ReadFromArguments(const std::vector<std::string>& args,
       if (args.size() > styleIndex) {
         std::string const& eol = args[styleIndex];
         if (eol == "LF" || eol == "UNIX") {
-          NewLineStyle = LF;
+          this->NewLineStyle = LF;
           return true;
         }
         if (eol == "CRLF" || eol == "WIN32" || eol == "DOS") {
-          NewLineStyle = CRLF;
+          this->NewLineStyle = CRLF;
           return true;
         }
         errorString = "NEWLINE_STYLE sets an unknown style, only LF, "
@@ -43,7 +43,7 @@ bool cmNewLineStyle::ReadFromArguments(const std::vector<std::string>& args,
 
 std::string cmNewLineStyle::GetCharacters() const
 {
-  switch (NewLineStyle) {
+  switch (this->NewLineStyle) {
     case Invalid:
       return "";
     case LF:
@@ -56,10 +56,10 @@ std::string cmNewLineStyle::GetCharacters() const
 
 void cmNewLineStyle::SetStyle(Style style)
 {
-  NewLineStyle = style;
+  this->NewLineStyle = style;
 }
 
 cmNewLineStyle::Style cmNewLineStyle::GetStyle() const
 {
-  return NewLineStyle;
+  return this->NewLineStyle;
 }
diff --git a/Source/cmNinjaLinkLineComputer.cxx b/Source/cmNinjaLinkLineComputer.cxx
index 7fbeeeaa39..2304ad2841 100644
--- a/Source/cmNinjaLinkLineComputer.cxx
+++ b/Source/cmNinjaLinkLineComputer.cxx
@@ -18,5 +18,5 @@ cmNinjaLinkLineComputer::cmNinjaLinkLineComputer(
 std::string cmNinjaLinkLineComputer::ConvertToLinkReference(
   std::string const& lib) const
 {
-  return GG->ConvertToNinjaPath(lib);
+  return this->GG->ConvertToNinjaPath(lib);
 }
diff --git a/Source/cmNinjaLinkLineDeviceComputer.cxx b/Source/cmNinjaLinkLineDeviceComputer.cxx
index 84c1b37d3f..f66e2f511d 100644
--- a/Source/cmNinjaLinkLineDeviceComputer.cxx
+++ b/Source/cmNinjaLinkLineDeviceComputer.cxx
@@ -16,5 +16,5 @@ cmNinjaLinkLineDeviceComputer::cmNinjaLinkLineDeviceComputer(
 std::string cmNinjaLinkLineDeviceComputer::ConvertToLinkReference(
   std::string const& lib) const
 {
-  return GG->ConvertToNinjaPath(lib);
+  return this->GG->ConvertToNinjaPath(lib);
 }
diff --git a/Source/cmNinjaNormalTargetGenerator.cxx b/Source/cmNinjaNormalTargetGenerator.cxx
index a5b9466a29..620b8ffde3 100644
--- a/Source/cmNinjaNormalTargetGenerator.cxx
+++ b/Source/cmNinjaNormalTargetGenerator.cxx
@@ -49,7 +49,7 @@ cmNinjaNormalTargetGenerator::cmNinjaNormalTargetGenerator(
     // on Windows the output dir is already needed at compile time
     // ensure the directory exists (OutDir test)
     for (auto const& config : this->GetConfigNames()) {
-      EnsureDirectoryExists(target->GetDirectory(config));
+      this->EnsureDirectoryExists(target->GetDirectory(config));
     }
   }
 
@@ -306,7 +306,7 @@ void cmNinjaNormalTargetGenerator::WriteDeviceLinkRules(
 {
   const cmMakefile* mf = this->GetMakefile();
 
-  cmNinjaRule rule(LanguageLinkerCudaDeviceRule(config));
+  cmNinjaRule rule(this->LanguageLinkerCudaDeviceRule(config));
   rule.Command = this->GetLocalGenerator()->BuildCommandLine(
     { cmStrCat(mf->GetRequiredDefinition("CMAKE_CUDA_DEVICE_LINKER"),
                " -arch=$ARCH $REGISTER -o=$out $in") });
@@ -334,13 +334,13 @@ void cmNinjaNormalTargetGenerator::WriteDeviceLinkRules(
   rulePlaceholderExpander->ExpandRuleVariables(this->GetLocalGenerator(),
                                                compileCmd, vars);
 
-  rule.Name = LanguageLinkerCudaDeviceCompileRule(config);
+  rule.Name = this->LanguageLinkerCudaDeviceCompileRule(config);
   rule.Command = this->GetLocalGenerator()->BuildCommandLine({ compileCmd });
   rule.Comment = "Rule for compiling CUDA device stubs.";
   rule.Description = "Compiling CUDA device stub $out";
   this->GetGlobalGenerator()->AddRule(rule);
 
-  rule.Name = LanguageLinkerCudaFatbinaryRule(config);
+  rule.Name = this->LanguageLinkerCudaFatbinaryRule(config);
   rule.Command = this->GetLocalGenerator()->BuildCommandLine(
     { cmStrCat(mf->GetRequiredDefinition("CMAKE_CUDA_FATBINARY"),
                " -64 -cmdline=--compile-only -compress-all -link "
@@ -385,7 +385,7 @@ void cmNinjaNormalTargetGenerator::WriteLinkRule(bool useResponseFile,
 
     // build response file name
     std::string cmakeLinkVar = cmakeVarLang + "_RESPONSE_FILE_LINK_FLAG";
-    cmProp flag = GetMakefile()->GetDefinition(cmakeLinkVar);
+    cmProp flag = this->GetMakefile()->GetDefinition(cmakeLinkVar);
 
     if (flag) {
       responseFlag = *flag;
@@ -673,7 +673,7 @@ void cmNinjaNormalTargetGenerator::WriteDeviceLinkStatement(
   targetOutputDir = globalGen->ExpandCFGIntDir(targetOutputDir, config);
 
   std::string targetOutputReal =
-    ConvertToNinjaPath(targetOutputDir + "cmake_device_link" + objExt);
+    this->ConvertToNinjaPath(targetOutputDir + "cmake_device_link" + objExt);
 
   if (firstForConfig) {
     globalGen->GetByproductsForCleanTarget(config).push_back(targetOutputReal);
@@ -730,7 +730,7 @@ void cmNinjaNormalTargetGenerator::WriteDeviceLinkStatements(
              this->GetGlobalGenerator()->ConfigDirectory(config));
   const std::string ninjaOutputDir = this->ConvertToNinjaPath(objectDir);
 
-  cmNinjaBuild fatbinary(LanguageLinkerCudaFatbinaryRule(config));
+  cmNinjaBuild fatbinary(this->LanguageLinkerCudaFatbinaryRule(config));
 
   // Link device code for each architecture.
   for (const std::string& architectureKind : architectures) {
@@ -744,7 +744,7 @@ void cmNinjaNormalTargetGenerator::WriteDeviceLinkStatements(
       cmStrCat(" -im=profile=sm_", architecture, ",file=", cubin);
     fatbinary.ExplicitDeps.emplace_back(cubin);
 
-    cmNinjaBuild dlink(LanguageLinkerCudaDeviceRule(config));
+    cmNinjaBuild dlink(this->LanguageLinkerCudaDeviceRule(config));
     dlink.ExplicitDeps = explicitDeps;
     dlink.Outputs = { cubin };
     dlink.Variables["ARCH"] = cmStrCat("sm_", architecture);
@@ -767,7 +767,7 @@ void cmNinjaNormalTargetGenerator::WriteDeviceLinkStatements(
                                          fatbinary);
 
   // Compile the stub that registers the kernels and contains the fatbinaries.
-  cmNinjaBuild dcompile(LanguageLinkerCudaDeviceCompileRule(config));
+  cmNinjaBuild dcompile(this->LanguageLinkerCudaDeviceCompileRule(config));
   dcompile.Outputs = { output };
   dcompile.ExplicitDeps = { cmStrCat(ninjaOutputDir, "/cmake_cuda_fatbin.h") };
   dcompile.Variables["FATBIN"] =
@@ -787,7 +787,7 @@ void cmNinjaNormalTargetGenerator::WriteNvidiaDeviceLinkStatement(
   cmGeneratorTarget* genTarget = this->GetGeneratorTarget();
   cmGlobalNinjaGenerator* globalGen = this->GetGlobalGenerator();
 
-  std::string targetOutputImplib = ConvertToNinjaPath(
+  std::string targetOutputImplib = this->ConvertToNinjaPath(
     genTarget->GetFullPath(config, cmStateEnums::ImportLibraryArtifact));
 
   if (config != fileConfig) {
@@ -806,7 +806,7 @@ void cmNinjaNormalTargetGenerator::WriteNvidiaDeviceLinkStatement(
            ->GetFullName(fileConfig, cmStateEnums::ImportLibraryArtifact)
            .empty() &&
         targetOutputImplib ==
-          ConvertToNinjaPath(genTarget->GetFullPath(
+          this->ConvertToNinjaPath(genTarget->GetFullPath(
             fileConfig, cmStateEnums::ImportLibraryArtifact))) {
       return;
     }
@@ -882,16 +882,16 @@ void cmNinjaNormalTargetGenerator::WriteNvidiaDeviceLinkStatement(
     const std::string impLibPath = localGen.ConvertToOutputFormat(
       targetOutputImplib, cmOutputConverter::SHELL);
     vars["TARGET_IMPLIB"] = impLibPath;
-    EnsureParentDirectoryExists(impLibPath);
+    this->EnsureParentDirectoryExists(impLibPath);
   }
 
   const std::string objPath =
-    cmStrCat(GetGeneratorTarget()->GetSupportDirectory(),
+    cmStrCat(this->GetGeneratorTarget()->GetSupportDirectory(),
              globalGen->ConfigDirectory(config));
 
   vars["OBJECT_DIR"] = this->GetLocalGenerator()->ConvertToOutputFormat(
     this->ConvertToNinjaPath(objPath), cmOutputConverter::SHELL);
-  EnsureDirectoryExists(objPath);
+  this->EnsureDirectoryExists(objPath);
 
   this->SetMsvcTargetPdbVariable(vars, config);
 
@@ -933,21 +933,22 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement(
   cmGlobalNinjaGenerator* globalGen = this->GetGlobalGenerator();
   cmGeneratorTarget* gt = this->GetGeneratorTarget();
 
-  std::string targetOutput = ConvertToNinjaPath(gt->GetFullPath(config));
-  std::string targetOutputReal = ConvertToNinjaPath(
+  std::string targetOutput = this->ConvertToNinjaPath(gt->GetFullPath(config));
+  std::string targetOutputReal = this->ConvertToNinjaPath(
     gt->GetFullPath(config, cmStateEnums::RuntimeBinaryArtifact,
                     /*realname=*/true));
-  std::string targetOutputImplib = ConvertToNinjaPath(
+  std::string targetOutputImplib = this->ConvertToNinjaPath(
     gt->GetFullPath(config, cmStateEnums::ImportLibraryArtifact));
 
   if (config != fileConfig) {
-    if (targetOutput == ConvertToNinjaPath(gt->GetFullPath(fileConfig))) {
+    if (targetOutput ==
+        this->ConvertToNinjaPath(gt->GetFullPath(fileConfig))) {
       return;
     }
     if (targetOutputReal ==
-        ConvertToNinjaPath(gt->GetFullPath(fileConfig,
-                                           cmStateEnums::RuntimeBinaryArtifact,
-                                           /*realname=*/true))) {
+        this->ConvertToNinjaPath(
+          gt->GetFullPath(fileConfig, cmStateEnums::RuntimeBinaryArtifact,
+                          /*realname=*/true))) {
       return;
     }
     if (!gt->GetFullName(config, cmStateEnums::ImportLibraryArtifact)
@@ -955,7 +956,7 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement(
         !gt->GetFullName(fileConfig, cmStateEnums::ImportLibraryArtifact)
            .empty() &&
         targetOutputImplib ==
-          ConvertToNinjaPath(gt->GetFullPath(
+          this->ConvertToNinjaPath(gt->GetFullPath(
             fileConfig, cmStateEnums::ImportLibraryArtifact))) {
       return;
     }
@@ -1095,7 +1096,8 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement(
   std::vector<std::string> extraISPCObjects =
     this->GetGeneratorTarget()->GetGeneratedISPCObjects(config);
   std::transform(extraISPCObjects.begin(), extraISPCObjects.end(),
-                 std::back_inserter(linkBuild.ExplicitDeps), MapToNinjaPath());
+                 std::back_inserter(linkBuild.ExplicitDeps),
+                 this->MapToNinjaPath());
 
   linkBuild.ImplicitDeps =
     this->ComputeLinkDeps(this->TargetLinkLanguage(config), config);
@@ -1189,7 +1191,7 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement(
     const std::string impLibPath = localGen.ConvertToOutputFormat(
       targetOutputImplib, cmOutputConverter::SHELL);
     vars["TARGET_IMPLIB"] = impLibPath;
-    EnsureParentDirectoryExists(impLibPath);
+    this->EnsureParentDirectoryExists(impLibPath);
     if (gt->HasImportLibrary(config)) {
       byproducts.push_back(targetOutputImplib);
       if (firstForConfig) {
@@ -1218,7 +1220,7 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement(
     cmStrCat(gt->GetSupportDirectory(), globalGen->ConfigDirectory(config));
   vars["OBJECT_DIR"] = this->GetLocalGenerator()->ConvertToOutputFormat(
     this->ConvertToNinjaPath(objPath), cmOutputConverter::SHELL);
-  EnsureDirectoryExists(objPath);
+  this->EnsureDirectoryExists(objPath);
 
   std::string& linkLibraries = vars["LINK_LIBRARIES"];
   std::string& link_path = vars["LINK_PATH"];
@@ -1247,11 +1249,11 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement(
         localGen.AppendCustomCommandLines(ccg, *cmdLineLists[i]);
         std::vector<std::string> const& ccByproducts = ccg.GetByproducts();
         std::transform(ccByproducts.begin(), ccByproducts.end(),
-                       std::back_inserter(byproducts), MapToNinjaPath());
+                       std::back_inserter(byproducts), this->MapToNinjaPath());
         std::transform(
           ccByproducts.begin(), ccByproducts.end(),
           std::back_inserter(globalGen->GetByproductsForCleanTarget()),
-          MapToNinjaPath());
+          this->MapToNinjaPath());
       }
     }
   }
@@ -1272,7 +1274,7 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement(
     cmd += this->GetLocalGenerator()->ConvertToOutputFormat(
       obj_list_file, cmOutputConverter::SHELL);
 
-    cmProp nm_executable = GetMakefile()->GetDefinition("CMAKE_NM");
+    cmProp nm_executable = this->GetMakefile()->GetDefinition("CMAKE_NM");
     if (cmNonempty(nm_executable)) {
       cmd += " --nm=";
       cmd += this->LocalCommonGenerator->ConvertToOutputFormat(
@@ -1325,7 +1327,7 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement(
   // build response file name
   std::string cmakeLinkVar = cmakeVarLang + "_RESPONSE_FILE_LINK_FLAG";
 
-  cmProp flag = GetMakefile()->GetDefinition(cmakeLinkVar);
+  cmProp flag = this->GetMakefile()->GetDefinition(cmakeLinkVar);
 
   bool const lang_supports_response =
     !(this->TargetLinkLanguage(config) == "RC" ||
diff --git a/Source/cmNinjaTargetGenerator.cxx b/Source/cmNinjaTargetGenerator.cxx
index 9075563f09..18c9d82249 100644
--- a/Source/cmNinjaTargetGenerator.cxx
+++ b/Source/cmNinjaTargetGenerator.cxx
@@ -332,7 +332,8 @@ cmNinjaDeps cmNinjaTargetGenerator::ComputeLinkDeps(
 
   const std::vector<std::string>& deps = cli->GetDepends();
   cmNinjaDeps result(deps.size());
-  std::transform(deps.begin(), deps.end(), result.begin(), MapToNinjaPath());
+  std::transform(deps.begin(), deps.end(), result.begin(),
+                 this->MapToNinjaPath());
 
   // Add a dependency on the link definitions file, if any.
   if (cmGeneratorTarget::ModuleDefinitionInfo const* mdi =
@@ -353,7 +354,7 @@ cmNinjaDeps cmNinjaTargetGenerator::ComputeLinkDeps(
   std::vector<std::string> linkDeps;
   this->GeneratorTarget->GetLinkDepends(linkDeps, config, linkLanguage);
   std::transform(linkDeps.begin(), linkDeps.end(), std::back_inserter(result),
-                 MapToNinjaPath());
+                 this->MapToNinjaPath());
 
   return result;
 }
@@ -361,7 +362,7 @@ cmNinjaDeps cmNinjaTargetGenerator::ComputeLinkDeps(
 std::string cmNinjaTargetGenerator::GetSourceFilePath(
   cmSourceFile const* source) const
 {
-  return ConvertToNinjaPath(source->GetFullPath());
+  return this->ConvertToNinjaPath(source->GetFullPath());
 }
 
 std::string cmNinjaTargetGenerator::GetObjectFilePath(
@@ -442,7 +443,7 @@ std::string cmNinjaTargetGenerator::GetTargetOutputDir(
   const std::string& config) const
 {
   std::string dir = this->GeneratorTarget->GetDirectory(config);
-  return ConvertToNinjaPath(dir);
+  return this->ConvertToNinjaPath(dir);
 }
 
 std::string cmNinjaTargetGenerator::GetTargetFilePath(
@@ -479,13 +480,13 @@ bool cmNinjaTargetGenerator::SetMsvcTargetPdbVariable(
     }
 
     vars["TARGET_PDB"] = this->GetLocalGenerator()->ConvertToOutputFormat(
-      ConvertToNinjaPath(pdbPath), cmOutputConverter::SHELL);
+      this->ConvertToNinjaPath(pdbPath), cmOutputConverter::SHELL);
     vars["TARGET_COMPILE_PDB"] =
       this->GetLocalGenerator()->ConvertToOutputFormat(
-        ConvertToNinjaPath(compilePdbPath), cmOutputConverter::SHELL);
+        this->ConvertToNinjaPath(compilePdbPath), cmOutputConverter::SHELL);
 
-    EnsureParentDirectoryExists(pdbPath);
-    EnsureParentDirectoryExists(compilePdbPath);
+    this->EnsureParentDirectoryExists(pdbPath);
+    this->EnsureParentDirectoryExists(compilePdbPath);
     return true;
   }
   return false;
@@ -605,7 +606,7 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang,
     this->GetLocalGenerator()->CreateRulePlaceholderExpander());
 
   std::string const tdi = this->GetLocalGenerator()->ConvertToOutputFormat(
-    ConvertToNinjaPath(this->GetTargetDependInfoPath(lang, config)),
+    this->ConvertToNinjaPath(this->GetTargetDependInfoPath(lang, config)),
     cmLocalGenerator::SHELL);
 
   std::string launcher;
@@ -922,7 +923,8 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatements(
       config);
   }
   if (firstForConfig) {
-    cmProp pchExtension = GetMakefile()->GetDefinition("CMAKE_PCH_EXTENSION");
+    cmProp pchExtension =
+      this->GetMakefile()->GetDefinition("CMAKE_PCH_EXTENSION");
 
     std::vector<cmSourceFile const*> externalObjects;
     this->GeneratorTarget->GetExternalObjects(externalObjects, config);
@@ -956,9 +958,11 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatements(
       const std::vector<std::string>& ccoutputs = ccg.GetOutputs();
       const std::vector<std::string>& ccbyproducts = ccg.GetByproducts();
       std::transform(ccoutputs.begin(), ccoutputs.end(),
-                     std::back_inserter(orderOnlyDeps), MapToNinjaPath());
+                     std::back_inserter(orderOnlyDeps),
+                     this->MapToNinjaPath());
       std::transform(ccbyproducts.begin(), ccbyproducts.end(),
-                     std::back_inserter(orderOnlyDeps), MapToNinjaPath());
+                     std::back_inserter(orderOnlyDeps),
+                     this->MapToNinjaPath());
     }
 
     std::sort(orderOnlyDeps.begin(), orderOnlyDeps.end());
@@ -1143,7 +1147,7 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatement(
   // build response file name
   std::string cmakeLinkVar = cmStrCat(cmakeVarLang, "_RESPONSE_FILE_FLAG");
 
-  cmProp flag = GetMakefile()->GetDefinition(cmakeLinkVar);
+  cmProp flag = this->GetMakefile()->GetDefinition(cmakeLinkVar);
 
   bool const lang_supports_response =
     !(language == "RC" || (language == "CUDA" && !flag));
@@ -1240,7 +1244,7 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatement(
     }
     std::transform(depList.begin(), depList.end(),
                    std::back_inserter(objBuild.ImplicitDeps),
-                   MapToNinjaPath());
+                   this->MapToNinjaPath());
   }
 
   objBuild.OrderOnlyDeps.push_back(this->OrderDependsTargetForTarget(config));
@@ -1329,7 +1333,7 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatement(
     vars["dyndep"] = dyndep;
   }
 
-  EnsureParentDirectoryExists(objectFileName);
+  this->EnsureParentDirectoryExists(objectFileName);
 
   vars["OBJECT_DIR"] = this->GetLocalGenerator()->ConvertToOutputFormat(
     objectDir, cmOutputConverter::SHELL);
@@ -1402,7 +1406,7 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatement(
     auto headers = this->GeneratorTarget->GetGeneratedISPCHeaders(config);
     if (!headers.empty()) {
       std::transform(headers.begin(), headers.end(), headers.begin(),
-                     MapToNinjaPath());
+                     this->MapToNinjaPath());
       objBuild.OrderOnlyDeps.insert(objBuild.OrderOnlyDeps.end(),
                                     headers.begin(), headers.end());
     }
@@ -1424,7 +1428,7 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatement(
       build.Comment = "Additional output files.";
       build.Outputs = cmExpandedList(evaluatedObjectOutputs);
       std::transform(build.Outputs.begin(), build.Outputs.end(),
-                     build.Outputs.begin(), MapToNinjaPath());
+                     build.Outputs.begin(), this->MapToNinjaPath());
       build.ExplicitDeps = objBuild.Outputs;
       this->GetGlobalGenerator()->WriteBuild(
         this->GetImplFileStream(fileConfig), build);
@@ -1644,7 +1648,7 @@ void cmNinjaTargetGenerator::EnsureDirectoryExists(
 void cmNinjaTargetGenerator::EnsureParentDirectoryExists(
   const std::string& path) const
 {
-  EnsureDirectoryExists(cmSystemTools::GetParentDirectory(path));
+  this->EnsureDirectoryExists(cmSystemTools::GetParentDirectory(path));
 }
 
 void cmNinjaTargetGenerator::MacOSXContentGeneratorType::operator()(
diff --git a/Source/cmNinjaUtilityTargetGenerator.cxx b/Source/cmNinjaUtilityTargetGenerator.cxx
index 0b62e1674b..3995624b2f 100644
--- a/Source/cmNinjaUtilityTargetGenerator.cxx
+++ b/Source/cmNinjaUtilityTargetGenerator.cxx
@@ -83,7 +83,8 @@ void cmNinjaUtilityTargetGenerator::WriteUtilBuildStatements(
         lg->AppendCustomCommandLines(ccg, commands);
         std::vector<std::string> const& ccByproducts = ccg.GetByproducts();
         std::transform(ccByproducts.begin(), ccByproducts.end(),
-                       std::back_inserter(util_outputs), MapToNinjaPath());
+                       std::back_inserter(util_outputs),
+                       this->MapToNinjaPath());
         if (ci.GetUsesTerminal()) {
           uses_terminal = true;
         }
@@ -103,9 +104,9 @@ void cmNinjaUtilityTargetGenerator::WriteUtilBuildStatements(
         const std::vector<std::string>& ccOutputs = ccg.GetOutputs();
         const std::vector<std::string>& ccByproducts = ccg.GetByproducts();
         std::transform(ccOutputs.begin(), ccOutputs.end(),
-                       std::back_inserter(deps), MapToNinjaPath());
+                       std::back_inserter(deps), this->MapToNinjaPath());
         std::transform(ccByproducts.begin(), ccByproducts.end(),
-                       std::back_inserter(deps), MapToNinjaPath());
+                       std::back_inserter(deps), this->MapToNinjaPath());
       }
     }
   }
diff --git a/Source/cmProcessOutput.cxx b/Source/cmProcessOutput.cxx
index 0fb4ff71ca..2d2676e2a6 100644
--- a/Source/cmProcessOutput.cxx
+++ b/Source/cmProcessOutput.cxx
@@ -126,7 +126,7 @@ bool cmProcessOutput::DecodeText(std::string raw, std::string& decoded,
 bool cmProcessOutput::DecodeText(const char* data, size_t length,
                                  std::string& decoded, size_t id)
 {
-  return DecodeText(std::string(data, length), decoded, id);
+  return this->DecodeText(std::string(data, length), decoded, id);
 }
 
 bool cmProcessOutput::DecodeText(std::vector<char> raw,
@@ -134,7 +134,7 @@ bool cmProcessOutput::DecodeText(std::vector<char> raw,
 {
   std::string str;
   const bool success =
-    DecodeText(std::string(raw.begin(), raw.end()), str, id);
+    this->DecodeText(std::string(raw.begin(), raw.end()), str, id);
   decoded.assign(str.begin(), str.end());
   return success;
 }
diff --git a/Source/cmPropertyMap.cxx b/Source/cmPropertyMap.cxx
index f22f36dd42..06e151ab6f 100644
--- a/Source/cmPropertyMap.cxx
+++ b/Source/cmPropertyMap.cxx
@@ -7,17 +7,17 @@
 
 void cmPropertyMap::Clear()
 {
-  Map_.clear();
+  this->Map_.clear();
 }
 
 void cmPropertyMap::SetProperty(const std::string& name, const char* value)
 {
   if (!value) {
-    Map_.erase(name);
+    this->Map_.erase(name);
     return;
   }
 
-  Map_[name] = value;
+  this->Map_[name] = value;
 }
 
 void cmPropertyMap::AppendProperty(const std::string& name,
@@ -29,7 +29,7 @@ void cmPropertyMap::AppendProperty(const std::string& name,
   }
 
   {
-    std::string& pVal = Map_[name];
+    std::string& pVal = this->Map_[name];
     if (!pVal.empty() && !asString) {
       pVal += ';';
     }
@@ -39,13 +39,13 @@ void cmPropertyMap::AppendProperty(const std::string& name,
 
 void cmPropertyMap::RemoveProperty(const std::string& name)
 {
-  Map_.erase(name);
+  this->Map_.erase(name);
 }
 
 cmProp cmPropertyMap::GetPropertyValue(const std::string& name) const
 {
-  auto it = Map_.find(name);
-  if (it != Map_.end()) {
+  auto it = this->Map_.find(name);
+  if (it != this->Map_.end()) {
     return &it->second;
   }
   return nullptr;
@@ -54,8 +54,8 @@ cmProp cmPropertyMap::GetPropertyValue(const std::string& name) const
 std::vector<std::string> cmPropertyMap::GetKeys() const
 {
   std::vector<std::string> keyList;
-  keyList.reserve(Map_.size());
-  for (auto const& item : Map_) {
+  keyList.reserve(this->Map_.size());
+  for (auto const& item : this->Map_) {
     keyList.push_back(item.first);
   }
   std::sort(keyList.begin(), keyList.end());
@@ -66,8 +66,8 @@ std::vector<std::pair<std::string, std::string>> cmPropertyMap::GetList() const
 {
   using StringPair = std::pair<std::string, std::string>;
   std::vector<StringPair> kvList;
-  kvList.reserve(Map_.size());
-  for (auto const& item : Map_) {
+  kvList.reserve(this->Map_.size());
+  for (auto const& item : this->Map_) {
     kvList.emplace_back(item.first, item.second);
   }
   std::sort(kvList.begin(), kvList.end(),
diff --git a/Source/cmQtAutoGen.h b/Source/cmQtAutoGen.h
index 2db1b842c7..e12a65384d 100644
--- a/Source/cmQtAutoGen.h
+++ b/Source/cmQtAutoGen.h
@@ -111,20 +111,20 @@ public:
     RccLister(std::string rccExecutable, std::vector<std::string> listOptions);
 
     //! The rcc executable
-    std::string const& RccExcutable() const { return RccExcutable_; }
+    std::string const& RccExcutable() const { return this->RccExcutable_; }
     void SetRccExecutable(std::string const& rccExecutable)
     {
-      RccExcutable_ = rccExecutable;
+      this->RccExcutable_ = rccExecutable;
     }
 
     //! The rcc executable list options
     std::vector<std::string> const& ListOptions() const
     {
-      return ListOptions_;
+      return this->ListOptions_;
     }
     void SetListOptions(std::vector<std::string> const& listOptions)
     {
-      ListOptions_ = listOptions;
+      this->ListOptions_ = listOptions;
     }
 
     /**
diff --git a/Source/cmQtAutoGenGlobalInitializer.cxx b/Source/cmQtAutoGenGlobalInitializer.cxx
index ff6fcd0b85..62b879f84a 100644
--- a/Source/cmQtAutoGenGlobalInitializer.cxx
+++ b/Source/cmQtAutoGenGlobalInitializer.cxx
@@ -57,7 +57,8 @@ cmQtAutoGenGlobalInitializer::cmQtAutoGenGlobalInitializer(
         if (targetName.empty()) {
           targetName = "autogen";
         }
-        GlobalAutoGenTargets_.emplace(localGen.get(), std::move(targetName));
+        this->GlobalAutoGenTargets_.emplace(localGen.get(),
+                                            std::move(targetName));
         globalAutoGenTarget = true;
       }
 
@@ -68,7 +69,8 @@ cmQtAutoGenGlobalInitializer::cmQtAutoGenGlobalInitializer(
         if (targetName.empty()) {
           targetName = "autorcc";
         }
-        GlobalAutoRccTargets_.emplace(localGen.get(), std::move(targetName));
+        this->GlobalAutoRccTargets_.emplace(localGen.get(),
+                                            std::move(targetName));
         globalAutoRccTarget = true;
       }
     }
@@ -99,16 +101,16 @@ cmQtAutoGenGlobalInitializer::cmQtAutoGenGlobalInitializer(
         continue;
       }
 
-      bool const moc = target->GetPropertyAsBool(kw().AUTOMOC);
-      bool const uic = target->GetPropertyAsBool(kw().AUTOUIC);
-      bool const rcc = target->GetPropertyAsBool(kw().AUTORCC);
+      bool const moc = target->GetPropertyAsBool(this->kw().AUTOMOC);
+      bool const uic = target->GetPropertyAsBool(this->kw().AUTOUIC);
+      bool const rcc = target->GetPropertyAsBool(this->kw().AUTORCC);
       if (moc || uic || rcc) {
         std::string const& mocExec =
-          target->GetSafeProperty(kw().AUTOMOC_EXECUTABLE);
+          target->GetSafeProperty(this->kw().AUTOMOC_EXECUTABLE);
         std::string const& uicExec =
-          target->GetSafeProperty(kw().AUTOUIC_EXECUTABLE);
+          target->GetSafeProperty(this->kw().AUTOUIC_EXECUTABLE);
         std::string const& rccExec =
-          target->GetSafeProperty(kw().AUTORCC_EXECUTABLE);
+          target->GetSafeProperty(this->kw().AUTORCC_EXECUTABLE);
 
         // We support Qt4, Qt5 and Qt6
         auto qtVersion = cmQtAutoGenInitializer::GetQtVersion(target.get());
@@ -141,9 +143,10 @@ cmQtAutoGenGlobalInitializer::cmQtAutoGenGlobalInitializer(
         }
         if (mocIsValid || uicIsValid || rccIsValid) {
           // Create autogen target initializer
-          Initializers_.emplace_back(cm::make_unique<cmQtAutoGenInitializer>(
-            this, target.get(), qtVersion.first, mocIsValid, uicIsValid,
-            rccIsValid, globalAutoGenTarget, globalAutoRccTarget));
+          this->Initializers_.emplace_back(
+            cm::make_unique<cmQtAutoGenInitializer>(
+              this, target.get(), qtVersion.first, mocIsValid, uicIsValid,
+              rccIsValid, globalAutoGenTarget, globalAutoRccTarget));
         }
       }
     }
@@ -184,8 +187,8 @@ void cmQtAutoGenGlobalInitializer::GetOrCreateGlobalTarget(
 void cmQtAutoGenGlobalInitializer::AddToGlobalAutoGen(
   cmLocalGenerator* localGen, std::string const& targetName)
 {
-  auto it = GlobalAutoGenTargets_.find(localGen);
-  if (it != GlobalAutoGenTargets_.end()) {
+  auto it = this->GlobalAutoGenTargets_.find(localGen);
+  if (it != this->GlobalAutoGenTargets_.end()) {
     cmGeneratorTarget* target = localGen->FindGeneratorTargetToUse(it->second);
     if (target != nullptr) {
       target->Target->AddUtility(targetName, false, localGen->GetMakefile());
@@ -196,8 +199,8 @@ void cmQtAutoGenGlobalInitializer::AddToGlobalAutoGen(
 void cmQtAutoGenGlobalInitializer::AddToGlobalAutoRcc(
   cmLocalGenerator* localGen, std::string const& targetName)
 {
-  auto it = GlobalAutoRccTargets_.find(localGen);
-  if (it != GlobalAutoRccTargets_.end()) {
+  auto it = this->GlobalAutoRccTargets_.find(localGen);
+  if (it != this->GlobalAutoRccTargets_.end()) {
     cmGeneratorTarget* target = localGen->FindGeneratorTargetToUse(it->second);
     if (target != nullptr) {
       target->Target->AddUtility(targetName, false, localGen->GetMakefile());
@@ -258,7 +261,7 @@ cmQtAutoGenGlobalInitializer::GetCompilerFeatures(
 
 bool cmQtAutoGenGlobalInitializer::generate()
 {
-  return (InitializeCustomTargets() && SetupCustomTargets());
+  return (this->InitializeCustomTargets() && this->SetupCustomTargets());
 }
 
 bool cmQtAutoGenGlobalInitializer::InitializeCustomTargets()
@@ -266,19 +269,19 @@ bool cmQtAutoGenGlobalInitializer::InitializeCustomTargets()
   // Initialize global autogen targets
   {
     std::string const comment = "Global AUTOGEN target";
-    for (auto const& pair : GlobalAutoGenTargets_) {
-      GetOrCreateGlobalTarget(pair.first, pair.second, comment);
+    for (auto const& pair : this->GlobalAutoGenTargets_) {
+      this->GetOrCreateGlobalTarget(pair.first, pair.second, comment);
     }
   }
   // Initialize global autorcc targets
   {
     std::string const comment = "Global AUTORCC target";
-    for (auto const& pair : GlobalAutoRccTargets_) {
-      GetOrCreateGlobalTarget(pair.first, pair.second, comment);
+    for (auto const& pair : this->GlobalAutoRccTargets_) {
+      this->GetOrCreateGlobalTarget(pair.first, pair.second, comment);
     }
   }
   // Initialize per target autogen targets
-  for (auto& initializer : Initializers_) {
+  for (auto& initializer : this->Initializers_) {
     if (!initializer->InitCustomTargets()) {
       return false;
     }
@@ -288,7 +291,7 @@ bool cmQtAutoGenGlobalInitializer::InitializeCustomTargets()
 
 bool cmQtAutoGenGlobalInitializer::SetupCustomTargets()
 {
-  for (auto& initializer : Initializers_) {
+  for (auto& initializer : this->Initializers_) {
     if (!initializer->SetupCustomTargets()) {
       return false;
     }
diff --git a/Source/cmQtAutoGenGlobalInitializer.h b/Source/cmQtAutoGenGlobalInitializer.h
index cdae137510..ea3821d7ae 100644
--- a/Source/cmQtAutoGenGlobalInitializer.h
+++ b/Source/cmQtAutoGenGlobalInitializer.h
@@ -50,7 +50,7 @@ public:
     std::vector<std::unique_ptr<cmLocalGenerator>> const& localGenerators);
   ~cmQtAutoGenGlobalInitializer();
 
-  Keywords const& kw() const { return Keywords_; };
+  Keywords const& kw() const { return this->Keywords_; };
 
   bool generate();
 
diff --git a/Source/cmQtAutoGenInitializer.cxx b/Source/cmQtAutoGenInitializer.cxx
index 1f74578ef1..bfe174c9e1 100644
--- a/Source/cmQtAutoGenInitializer.cxx
+++ b/Source/cmQtAutoGenInitializer.cxx
@@ -152,7 +152,8 @@ std::vector<std::string> SearchPathSanitizer::operator()(
   res.reserve(paths.size());
   for (std::string const& srcPath : paths) {
     // Collapse relative paths
-    std::string path = cmSystemTools::CollapseFullPath(srcPath, SourcePath_);
+    std::string path =
+      cmSystemTools::CollapseFullPath(srcPath, this->SourcePath_);
     // Remove suffix slashes
     while (cmHasSuffix(path, '/')) {
       path.pop_back();
@@ -172,14 +173,17 @@ public:
   // -- Single value
   void Set(std::string const& key, std::string const& value)
   {
-    Value_[key] = value;
+    this->Value_[key] = value;
   }
   void SetConfig(std::string const& key,
                  cmQtAutoGenInitializer::ConfigString const& cfgStr);
-  void SetBool(std::string const& key, bool value) { Value_[key] = value; }
+  void SetBool(std::string const& key, bool value)
+  {
+    this->Value_[key] = value;
+  }
   void SetUInt(std::string const& key, unsigned int value)
   {
-    Value_[key] = value;
+    this->Value_[key] = value;
   }
 
   // -- Array utility
@@ -211,9 +215,9 @@ private:
 void InfoWriter::SetConfig(std::string const& key,
                            cmQtAutoGenInitializer::ConfigString const& cfgStr)
 {
-  Set(key, cfgStr.Default);
+  this->Set(key, cfgStr.Default);
   for (auto const& item : cfgStr.Config) {
-    Set(cmStrCat(key, '_', item.first), item.second);
+    this->Set(cmStrCat(key, '_', item.first), item.second);
   }
 }
 
@@ -243,14 +247,14 @@ void InfoWriter::MakeStringArray(Json::Value& jval, CONT const& container)
 template <typename CONT>
 void InfoWriter::SetArray(std::string const& key, CONT const& container)
 {
-  MakeStringArray(Value_[key], container);
+  MakeStringArray(this->Value_[key], container);
 }
 
 template <typename CONT, typename FUNC>
 void InfoWriter::SetArrayArray(std::string const& key, CONT const& container,
                                FUNC func)
 {
-  Json::Value& jval = Value_[key];
+  Json::Value& jval = this->Value_[key];
   if (MakeArray(jval, container)) {
     Json::ArrayIndex ii = 0;
     for (auto const& citem : container) {
@@ -266,9 +270,9 @@ void InfoWriter::SetConfigArray(
   std::string const& key,
   cmQtAutoGenInitializer::ConfigStrings<CONT> const& cfgStr)
 {
-  SetArray(key, cfgStr.Default);
+  this->SetArray(key, cfgStr.Default);
   for (auto const& item : cfgStr.Config) {
-    SetArray(cmStrCat(key, '_', item.first), item.second);
+    this->SetArray(cmStrCat(key, '_', item.first), item.second);
   }
 }
 
@@ -283,7 +287,7 @@ bool InfoWriter::Save(std::string const& filename)
 
   Json::StyledStreamWriter jsonWriter;
   try {
-    jsonWriter.write(fileStream, Value_);
+    jsonWriter.write(fileStream, this->Value_);
   } catch (...) {
     return false;
   }
@@ -306,11 +310,11 @@ cmQtAutoGenInitializer::cmQtAutoGenInitializer(
   , PathCheckSum(genTarget->Makefile)
   , QtVersion(qtVersion)
 {
-  AutogenTarget.GlobalTarget = globalAutogenTarget;
-  Moc.Enabled = mocEnabled;
-  Uic.Enabled = uicEnabled;
-  Rcc.Enabled = rccEnabled;
-  Rcc.GlobalTarget = globalAutoRccTarget;
+  this->AutogenTarget.GlobalTarget = globalAutogenTarget;
+  this->Moc.Enabled = mocEnabled;
+  this->Uic.Enabled = uicEnabled;
+  this->Rcc.Enabled = rccEnabled;
+  this->Rcc.GlobalTarget = globalAutoRccTarget;
 }
 
 bool cmQtAutoGenInitializer::InitCustomTargets()
@@ -416,8 +420,8 @@ bool cmQtAutoGenInitializer::InitCustomTargets()
     cmSystemTools::ConvertToUnixSlashes(this->Dir.Work);
 
     // Include directory
-    ConfigFileNames(this->Dir.Include, cmStrCat(this->Dir.Build, "/include"),
-                    "");
+    this->ConfigFileNames(this->Dir.Include,
+                          cmStrCat(this->Dir.Build, "/include"), "");
     this->Dir.IncludeGenExp = this->Dir.Include.Default;
     if (this->MultiConfig) {
       this->Dir.IncludeGenExp += "_$<CONFIG>";
@@ -427,12 +431,12 @@ bool cmQtAutoGenInitializer::InitCustomTargets()
   // Moc, Uic and _autogen target settings
   if (this->MocOrUicEnabled()) {
     // Init moc specific settings
-    if (this->Moc.Enabled && !InitMoc()) {
+    if (this->Moc.Enabled && !this->InitMoc()) {
       return false;
     }
 
     // Init uic specific settings
-    if (this->Uic.Enabled && !InitUic()) {
+    if (this->Uic.Enabled && !this->InitUic()) {
       return false;
     }
 
@@ -459,14 +463,14 @@ bool cmQtAutoGenInitializer::InitCustomTargets()
         cmStrCat(this->Dir.Info, "/AutogenInfo.json");
 
       // Used settings file
-      ConfigFileNames(this->AutogenTarget.SettingsFile,
-                      cmStrCat(this->Dir.Info, "/AutogenUsed"), ".txt");
-      ConfigFileClean(this->AutogenTarget.SettingsFile);
+      this->ConfigFileNames(this->AutogenTarget.SettingsFile,
+                            cmStrCat(this->Dir.Info, "/AutogenUsed"), ".txt");
+      this->ConfigFileClean(this->AutogenTarget.SettingsFile);
 
       // Parse cache file
-      ConfigFileNames(this->AutogenTarget.ParseCacheFile,
-                      cmStrCat(this->Dir.Info, "/ParseCache"), ".txt");
-      ConfigFileClean(this->AutogenTarget.ParseCacheFile);
+      this->ConfigFileNames(this->AutogenTarget.ParseCacheFile,
+                            cmStrCat(this->Dir.Info, "/ParseCache"), ".txt");
+      this->ConfigFileClean(this->AutogenTarget.ParseCacheFile);
     }
 
     // Autogen target: Compute user defined dependencies
@@ -535,7 +539,7 @@ bool cmQtAutoGenInitializer::InitCustomTargets()
   }
 
   // Init rcc specific settings
-  if (this->Rcc.Enabled && !InitRcc()) {
+  if (this->Rcc.Enabled && !this->InitRcc()) {
     return false;
   }
 
@@ -572,8 +576,9 @@ bool cmQtAutoGenInitializer::InitMoc()
       cmStrCat(this->Dir.Build, "/mocs_compilation.cpp");
     this->Moc.CompilationFileGenex = this->Moc.CompilationFile.Default;
   } else {
-    ConfigFileNames(this->Moc.CompilationFile,
-                    cmStrCat(this->Dir.Build, "/mocs_compilation"), ".cpp");
+    this->ConfigFileNames(this->Moc.CompilationFile,
+                          cmStrCat(this->Dir.Build, "/mocs_compilation"),
+                          ".cpp");
     if (this->MultiConfig) {
       this->Moc.CompilationFileGenex =
         cmStrCat(this->Dir.Build, "/mocs_compilation_$<CONFIG>.cpp"_s);
@@ -590,8 +595,8 @@ bool cmQtAutoGenInitializer::InitMoc()
                                      this->Moc.PredefsCmd);
     // Header
     if (!this->Moc.PredefsCmd.empty()) {
-      ConfigFileNames(this->Moc.PredefsFile,
-                      cmStrCat(this->Dir.Build, "/moc_predefs"), ".h");
+      this->ConfigFileNames(this->Moc.PredefsFile,
+                            cmStrCat(this->Dir.Build, "/moc_predefs"), ".h");
     }
   }
 
@@ -1035,7 +1040,7 @@ bool cmQtAutoGenInitializer::InitScanFiles()
                                         qrc.QrcName, '_', qrc.QrcPathChecksum);
       qrc.LockFile = cmStrCat(base, "_Lock.lock");
       qrc.InfoFile = cmStrCat(base, "_Info.json");
-      ConfigFileNames(qrc.SettingsFile, cmStrCat(base, "_Used"), ".txt");
+      this->ConfigFileNames(qrc.SettingsFile, cmStrCat(base, "_Used"), ".txt");
     }
     // rcc options
     for (Qrc& qrc : this->Rcc.Qrcs) {
@@ -1133,7 +1138,7 @@ bool cmQtAutoGenInitializer::InitAutogenTarget()
       usePRE_BUILD = false;
     }
     // Cannot use PRE_BUILD when a global autogen target is in place
-    if (AutogenTarget.GlobalTarget) {
+    if (this->AutogenTarget.GlobalTarget) {
       usePRE_BUILD = false;
     }
   }
diff --git a/Source/cmQtAutoGenerator.cxx b/Source/cmQtAutoGenerator.cxx
index ee2bc09375..ebb6bd7da5 100644
--- a/Source/cmQtAutoGenerator.cxx
+++ b/Source/cmQtAutoGenerator.cxx
@@ -18,10 +18,10 @@ cmQtAutoGenerator::Logger::Logger()
     if (cmSystemTools::GetEnv("VERBOSE", verbose) && !verbose.empty()) {
       unsigned long iVerbose = 0;
       if (cmStrToULong(verbose, &iVerbose)) {
-        SetVerbosity(static_cast<unsigned int>(iVerbose));
+        this->SetVerbosity(static_cast<unsigned int>(iVerbose));
       } else {
         // Non numeric verbosity
-        SetVerbose(cmIsOn(verbose));
+        this->SetVerbose(cmIsOn(verbose));
       }
     }
   }
@@ -29,9 +29,9 @@ cmQtAutoGenerator::Logger::Logger()
     std::string colorEnv;
     cmSystemTools::GetEnv("COLOR", colorEnv);
     if (!colorEnv.empty()) {
-      SetColorOutput(cmIsOn(colorEnv));
+      this->SetColorOutput(cmIsOn(colorEnv));
     } else {
-      SetColorOutput(true);
+      this->SetColorOutput(true);
     }
   }
 }
@@ -47,7 +47,7 @@ void cmQtAutoGenerator::Logger::RaiseVerbosity(unsigned int value)
 
 void cmQtAutoGenerator::Logger::SetColorOutput(bool value)
 {
-  ColorOutput_ = value;
+  this->ColorOutput_ = value;
 }
 
 std::string cmQtAutoGenerator::Logger::HeadLine(cm::string_view title)
@@ -61,7 +61,7 @@ void cmQtAutoGenerator::Logger::Info(GenT genType,
   std::string msg = cmStrCat(GeneratorName(genType), ": ", message,
                              cmHasSuffix(message, '\n') ? "" : "\n");
   {
-    std::lock_guard<std::mutex> lock(Mutex_);
+    std::lock_guard<std::mutex> lock(this->Mutex_);
     cmSystemTools::Stdout(msg);
   }
 }
@@ -80,7 +80,7 @@ void cmQtAutoGenerator::Logger::Warning(GenT genType,
                    message, cmHasSuffix(message, '\n') ? "\n" : "\n\n");
   }
   {
-    std::lock_guard<std::mutex> lock(Mutex_);
+    std::lock_guard<std::mutex> lock(this->Mutex_);
     cmSystemTools::Stdout(msg);
   }
 }
@@ -92,7 +92,7 @@ void cmQtAutoGenerator::Logger::Error(GenT genType,
     cmStrCat('\n', HeadLine(cmStrCat(GeneratorName(genType), " error")),
              message, cmHasSuffix(message, '\n') ? "\n" : "\n\n");
   {
-    std::lock_guard<std::mutex> lock(Mutex_);
+    std::lock_guard<std::mutex> lock(this->Mutex_);
     cmSystemTools::Stderr(msg);
   }
 }
@@ -108,7 +108,7 @@ void cmQtAutoGenerator::Logger::ErrorCommand(
   msg += cmStrCat(HeadLine("Output"), output,
                   cmHasSuffix(output, '\n') ? "\n" : "\n\n");
   {
-    std::lock_guard<std::mutex> lock(Mutex_);
+    std::lock_guard<std::mutex> lock(this->Mutex_);
     cmSystemTools::Stderr(msg);
   }
 }
@@ -215,7 +215,7 @@ cmQtAutoGenerator::~cmQtAutoGenerator() = default;
 bool cmQtAutoGenerator::InfoT::Read(std::istream& istr)
 {
   try {
-    istr >> Json_;
+    istr >> this->Json_;
   } catch (...) {
     return false;
   }
@@ -264,22 +264,22 @@ bool cmQtAutoGenerator::InfoT::GetJsonArray(
 
 std::string cmQtAutoGenerator::InfoT::ConfigKey(cm::string_view key) const
 {
-  return cmStrCat(key, '_', Gen_.InfoConfig());
+  return cmStrCat(key, '_', this->Gen_.InfoConfig());
 }
 
 bool cmQtAutoGenerator::InfoT::GetString(std::string const& key,
                                          std::string& value,
                                          bool required) const
 {
-  Json::Value const& jval = Json_[key];
+  Json::Value const& jval = this->Json_[key];
   if (!jval.isString()) {
     if (!jval.isNull() || required) {
-      return LogError(cmStrCat(key, " is not a string."));
+      return this->LogError(cmStrCat(key, " is not a string."));
     }
   } else {
     value = jval.asString();
     if (value.empty() && required) {
-      return LogError(cmStrCat(key, " is empty."));
+      return this->LogError(cmStrCat(key, " is empty."));
     }
   }
   return true;
@@ -290,32 +290,32 @@ bool cmQtAutoGenerator::InfoT::GetStringConfig(std::string const& key,
                                                bool required) const
 {
   { // Try config
-    std::string const configKey = ConfigKey(key);
-    Json::Value const& jval = Json_[configKey];
+    std::string const configKey = this->ConfigKey(key);
+    Json::Value const& jval = this->Json_[configKey];
     if (!jval.isNull()) {
       if (!jval.isString()) {
-        return LogError(cmStrCat(configKey, " is not a string."));
+        return this->LogError(cmStrCat(configKey, " is not a string."));
       }
       value = jval.asString();
       if (required && value.empty()) {
-        return LogError(cmStrCat(configKey, " is empty."));
+        return this->LogError(cmStrCat(configKey, " is empty."));
       }
       return true;
     }
   }
   // Try plain
-  return GetString(key, value, required);
+  return this->GetString(key, value, required);
 }
 
 bool cmQtAutoGenerator::InfoT::GetBool(std::string const& key, bool& value,
                                        bool required) const
 {
-  Json::Value const& jval = Json_[key];
+  Json::Value const& jval = this->Json_[key];
   if (jval.isBool()) {
     value = jval.asBool();
   } else {
     if (!jval.isNull() || required) {
-      return LogError(cmStrCat(key, " is not a boolean."));
+      return this->LogError(cmStrCat(key, " is not a boolean."));
     }
   }
   return true;
@@ -325,12 +325,12 @@ bool cmQtAutoGenerator::InfoT::GetUInt(std::string const& key,
                                        unsigned int& value,
                                        bool required) const
 {
-  Json::Value const& jval = Json_[key];
+  Json::Value const& jval = this->Json_[key];
   if (jval.isUInt()) {
     value = jval.asUInt();
   } else {
     if (!jval.isNull() || required) {
-      return LogError(cmStrCat(key, " is not an unsigned integer."));
+      return this->LogError(cmStrCat(key, " is not an unsigned integer."));
     }
   }
   return true;
@@ -340,10 +340,10 @@ bool cmQtAutoGenerator::InfoT::GetArray(std::string const& key,
                                         std::vector<std::string>& list,
                                         bool required) const
 {
-  Json::Value const& jval = Json_[key];
+  Json::Value const& jval = this->Json_[key];
   if (!jval.isArray()) {
     if (!jval.isNull() || required) {
-      return LogError(cmStrCat(key, " is not an array."));
+      return this->LogError(cmStrCat(key, " is not an array."));
     }
   }
   return GetJsonArray(list, jval) || !required;
@@ -353,10 +353,10 @@ bool cmQtAutoGenerator::InfoT::GetArray(std::string const& key,
                                         std::unordered_set<std::string>& list,
                                         bool required) const
 {
-  Json::Value const& jval = Json_[key];
+  Json::Value const& jval = this->Json_[key];
   if (!jval.isArray()) {
     if (!jval.isNull() || required) {
-      return LogError(cmStrCat(key, " is not an array."));
+      return this->LogError(cmStrCat(key, " is not an array."));
     }
   }
   return GetJsonArray(list, jval) || !required;
@@ -367,34 +367,35 @@ bool cmQtAutoGenerator::InfoT::GetArrayConfig(std::string const& key,
                                               bool required) const
 {
   { // Try config
-    std::string const configKey = ConfigKey(key);
-    Json::Value const& jval = Json_[configKey];
+    std::string const configKey = this->ConfigKey(key);
+    Json::Value const& jval = this->Json_[configKey];
     if (!jval.isNull()) {
       if (!jval.isArray()) {
-        return LogError(cmStrCat(configKey, " is not an array string."));
+        return this->LogError(cmStrCat(configKey, " is not an array string."));
       }
       if (!GetJsonArray(list, jval) && required) {
-        return LogError(cmStrCat(configKey, " is empty."));
+        return this->LogError(cmStrCat(configKey, " is empty."));
       }
       return true;
     }
   }
   // Try plain
-  return GetArray(key, list, required);
+  return this->GetArray(key, list, required);
 }
 
 bool cmQtAutoGenerator::InfoT::LogError(GenT genType,
                                         cm::string_view message) const
 {
-  Gen_.Log().Error(genType,
-                   cmStrCat("Info error in info file\n",
-                            Quoted(Gen_.InfoFile()), ":\n", message));
+  this->Gen_.Log().Error(genType,
+                         cmStrCat("Info error in info file\n",
+                                  Quoted(this->Gen_.InfoFile()), ":\n",
+                                  message));
   return false;
 }
 
 bool cmQtAutoGenerator::InfoT::LogError(cm::string_view message) const
 {
-  return LogError(Gen_.GenType_, message);
+  return this->LogError(this->Gen_.GenType_, message);
 }
 
 std::string cmQtAutoGenerator::SettingsFind(cm::string_view content,
@@ -418,10 +419,10 @@ std::string cmQtAutoGenerator::SettingsFind(cm::string_view content,
 std::string cmQtAutoGenerator::MessagePath(cm::string_view path) const
 {
   std::string res;
-  if (cmHasPrefix(path, ProjectDirs().Source)) {
-    res = cmStrCat("SRC:", path.substr(ProjectDirs().Source.size()));
-  } else if (cmHasPrefix(path, ProjectDirs().Binary)) {
-    res = cmStrCat("BIN:", path.substr(ProjectDirs().Binary.size()));
+  if (cmHasPrefix(path, this->ProjectDirs().Source)) {
+    res = cmStrCat("SRC:", path.substr(this->ProjectDirs().Source.size()));
+  } else if (cmHasPrefix(path, this->ProjectDirs().Binary)) {
+    res = cmStrCat("BIN:", path.substr(this->ProjectDirs().Binary.size()));
   } else {
     res = std::string(path);
   }
@@ -431,17 +432,18 @@ std::string cmQtAutoGenerator::MessagePath(cm::string_view path) const
 bool cmQtAutoGenerator::Run(cm::string_view infoFile, cm::string_view config)
 {
   // Info config
-  InfoConfig_ = std::string(config);
+  this->InfoConfig_ = std::string(config);
 
   // Info file
-  InfoFile_ = std::string(infoFile);
-  cmSystemTools::CollapseFullPath(InfoFile_);
-  InfoDir_ = cmSystemTools::GetFilenamePath(InfoFile_);
+  this->InfoFile_ = std::string(infoFile);
+  cmSystemTools::CollapseFullPath(this->InfoFile_);
+  this->InfoDir_ = cmSystemTools::GetFilenamePath(this->InfoFile_);
 
   // Load info file time
-  if (!InfoFileTime_.Load(InfoFile_)) {
+  if (!this->InfoFileTime_.Load(this->InfoFile_)) {
     cmSystemTools::Stderr(cmStrCat("AutoGen: The info file ",
-                                   Quoted(InfoFile_), " is not readable\n"));
+                                   Quoted(this->InfoFile_),
+                                   " is not readable\n"));
     return false;
   }
 
@@ -450,17 +452,18 @@ bool cmQtAutoGenerator::Run(cm::string_view infoFile, cm::string_view config)
 
     // Read info file
     {
-      cmsys::ifstream ifs(InfoFile_.c_str(),
+      cmsys::ifstream ifs(this->InfoFile_.c_str(),
                           (std::ios::in | std::ios::binary));
       if (!ifs) {
-        Log().Error(
-          GenType_,
-          cmStrCat("Could not to open info file ", Quoted(InfoFile_)));
+        this->Log().Error(
+          this->GenType_,
+          cmStrCat("Could not to open info file ", Quoted(this->InfoFile_)));
         return false;
       }
       if (!info.Read(ifs)) {
-        Log().Error(GenType_,
-                    cmStrCat("Could not read info file ", Quoted(InfoFile_)));
+        this->Log().Error(
+          this->GenType_,
+          cmStrCat("Could not read info file ", Quoted(this->InfoFile_)));
         return false;
       }
     }
@@ -470,15 +473,17 @@ bool cmQtAutoGenerator::Run(cm::string_view infoFile, cm::string_view config)
       unsigned int verbosity = 0;
       // Info: setup project directories
       if (!info.GetUInt("VERBOSITY", verbosity, false) ||
-          !info.GetString("CMAKE_SOURCE_DIR", ProjectDirs_.Source, true) ||
-          !info.GetString("CMAKE_BINARY_DIR", ProjectDirs_.Binary, true) ||
+          !info.GetString("CMAKE_SOURCE_DIR", this->ProjectDirs_.Source,
+                          true) ||
+          !info.GetString("CMAKE_BINARY_DIR", this->ProjectDirs_.Binary,
+                          true) ||
           !info.GetString("CMAKE_CURRENT_SOURCE_DIR",
-                          ProjectDirs_.CurrentSource, true) ||
+                          this->ProjectDirs_.CurrentSource, true) ||
           !info.GetString("CMAKE_CURRENT_BINARY_DIR",
-                          ProjectDirs_.CurrentBinary, true)) {
+                          this->ProjectDirs_.CurrentBinary, true)) {
         return false;
       }
-      Logger_.RaiseVerbosity(verbosity);
+      this->Logger_.RaiseVerbosity(verbosity);
     }
 
     // -- Call virtual init from info method.
diff --git a/Source/cmQtAutoGenerator.h b/Source/cmQtAutoGenerator.h
index b4f057d066..53fbd6929a 100644
--- a/Source/cmQtAutoGenerator.h
+++ b/Source/cmQtAutoGenerator.h
@@ -88,10 +88,10 @@ public:
   cmQtAutoGenerator& operator=(cmQtAutoGenerator const&) = delete;
 
   // -- Info options
-  std::string const& InfoFile() const { return InfoFile_; }
-  std::string const& InfoDir() const { return InfoDir_; }
-  cmFileTime const& InfoFileTime() const { return InfoFileTime_; }
-  std::string const& InfoConfig() const { return InfoConfig_; }
+  std::string const& InfoFile() const { return this->InfoFile_; }
+  std::string const& InfoDir() const { return this->InfoDir_; }
+  cmFileTime const& InfoFileTime() const { return this->InfoFileTime_; }
+  std::string const& InfoConfig() const { return this->InfoConfig_; }
 
   // -- Info file parsing
   /** Info file reader class. */
@@ -124,7 +124,7 @@ public:
 
     Json::Value const& GetValue(std::string const& key) const
     {
-      return Json_[key];
+      return this->Json_[key];
     }
 
     /** Returns true if strings were appended to the list.  */
@@ -150,7 +150,7 @@ public:
                                   cm::string_view key);
 
   // -- Directories
-  ProjectDirsT const& ProjectDirs() const { return ProjectDirs_; }
+  ProjectDirsT const& ProjectDirs() const { return this->ProjectDirs_; }
   std::string MessagePath(cm::string_view path) const;
 
   // -- Run
@@ -161,7 +161,7 @@ protected:
   virtual bool InitFromInfo(InfoT const& info) = 0;
   virtual bool Process() = 0;
   // - Utility classes
-  Logger const& Log() const { return Logger_; }
+  Logger const& Log() const { return this->Logger_; }
 
 private:
   // -- Generator type
diff --git a/Source/cmQtAutoMocUic.cxx b/Source/cmQtAutoMocUic.cxx
index c9d4268378..7365fdb654 100644
--- a/Source/cmQtAutoMocUic.cxx
+++ b/Source/cmQtAutoMocUic.cxx
@@ -313,22 +313,22 @@ public:
     //! Get the generator. Only valid during Process() call!
     cmQtAutoMocUicT* Gen() const
     {
-      return static_cast<cmQtAutoMocUicT*>(UserData());
+      return static_cast<cmQtAutoMocUicT*>(this->UserData());
     };
 
     // -- Accessors. Only valid during Process() call!
-    Logger const& Log() const { return Gen()->Log(); }
-    BaseSettingsT const& BaseConst() const { return Gen()->BaseConst(); }
-    BaseEvalT& BaseEval() const { return Gen()->BaseEval(); }
-    MocSettingsT const& MocConst() const { return Gen()->MocConst(); }
-    MocEvalT& MocEval() const { return Gen()->MocEval(); }
-    UicSettingsT const& UicConst() const { return Gen()->UicConst(); }
-    UicEvalT& UicEval() const { return Gen()->UicEval(); }
+    Logger const& Log() const { return this->Gen()->Log(); }
+    BaseSettingsT const& BaseConst() const { return this->Gen()->BaseConst(); }
+    BaseEvalT& BaseEval() const { return this->Gen()->BaseEval(); }
+    MocSettingsT const& MocConst() const { return this->Gen()->MocConst(); }
+    MocEvalT& MocEval() const { return this->Gen()->MocEval(); }
+    UicSettingsT const& UicConst() const { return this->Gen()->UicConst(); }
+    UicEvalT& UicEval() const { return this->Gen()->UicEval(); }
 
     // -- Logging
     std::string MessagePath(cm::string_view path) const
     {
-      return Gen()->MessagePath(path);
+      return this->Gen()->MessagePath(path);
     }
     // - Error logging with automatic abort
     void LogError(GenT genType, cm::string_view message) const;
@@ -541,9 +541,9 @@ public:
   UicEvalT& UicEval() { return this->UicEval_; }
 
   // -- Parallel job processing interface
-  cmWorkerPool& WorkerPool() { return WorkerPool_; }
-  void AbortError() { Abort(true); }
-  void AbortSuccess() { Abort(false); }
+  cmWorkerPool& WorkerPool() { return this->WorkerPool_; }
+  void AbortError() { this->Abort(true); }
+  void AbortSuccess() { this->Abort(false); }
 
   // -- Utility
   std::string AbsoluteBuildPath(cm::string_view relativePath) const;
@@ -597,19 +597,19 @@ cmQtAutoMocUicT::IncludeKeyT::IncludeKeyT(std::string const& key,
   , Base(cmSystemTools::GetFilenameWithoutLastExtension(key))
 {
   if (basePrefixLength != 0) {
-    Base = Base.substr(basePrefixLength);
+    this->Base = this->Base.substr(basePrefixLength);
   }
 }
 
 void cmQtAutoMocUicT::ParseCacheT::FileT::Clear()
 {
-  Moc.Macro.clear();
-  Moc.Include.Underscore.clear();
-  Moc.Include.Dot.clear();
-  Moc.Depends.clear();
+  this->Moc.Macro.clear();
+  this->Moc.Include.Underscore.clear();
+  this->Moc.Include.Dot.clear();
+  this->Moc.Depends.clear();
 
-  Uic.Include.clear();
-  Uic.Depends.clear();
+  this->Uic.Include.clear();
+  this->Uic.Depends.clear();
 }
 
 cmQtAutoMocUicT::ParseCacheT::GetOrInsertT
@@ -617,15 +617,15 @@ cmQtAutoMocUicT::ParseCacheT::GetOrInsert(std::string const& fileName)
 {
   // Find existing entry
   {
-    auto it = Map_.find(fileName);
-    if (it != Map_.end()) {
+    auto it = this->Map_.find(fileName);
+    if (it != this->Map_.end()) {
       return GetOrInsertT{ it->second, false };
     }
   }
 
   // Insert new entry
   return GetOrInsertT{
-    Map_.emplace(fileName, std::make_shared<FileT>()).first->second, true
+    this->Map_.emplace(fileName, std::make_shared<FileT>()).first->second, true
   };
 }
 
@@ -655,7 +655,7 @@ bool cmQtAutoMocUicT::ParseCacheT::ReadFromFile(std::string const& fileName)
     }
     // Check if this a file name line
     if (line.front() != ' ') {
-      fileHandle = GetOrInsert(line).first;
+      fileHandle = this->GetOrInsert(line).first;
       continue;
     }
 
@@ -702,7 +702,7 @@ bool cmQtAutoMocUicT::ParseCacheT::WriteToFile(std::string const& fileName)
     return false;
   }
   ofs << "# Generated by CMake. Changes will be overwritten.\n";
-  for (auto const& pair : Map_) {
+  for (auto const& pair : this->Map_) {
     ofs << pair.first << '\n';
     FileT const& file = *pair.second;
     if (!file.Moc.Macro.empty()) {
@@ -732,7 +732,7 @@ cmQtAutoMocUicT::BaseSettingsT::~BaseSettingsT() = default;
 
 cmQtAutoMocUicT::MocSettingsT::MocSettingsT()
 {
-  RegExpInclude.compile(
+  this->RegExpInclude.compile(
     "(^|\n)[ \t]*#[ \t]*include[ \t]+"
     "[\"<](([^ \">]+/)?moc_[^ \">/]+\\.cpp|[^ \">]+\\.moc)[\">]");
 }
@@ -741,14 +741,15 @@ cmQtAutoMocUicT::MocSettingsT::~MocSettingsT() = default;
 
 bool cmQtAutoMocUicT::MocSettingsT::skipped(std::string const& fileName) const
 {
-  return (!Enabled || (SkipList.find(fileName) != SkipList.end()));
+  return (!this->Enabled ||
+          (this->SkipList.find(fileName) != this->SkipList.end()));
 }
 
 std::string cmQtAutoMocUicT::MocSettingsT::MacrosString() const
 {
   std::string res;
-  const auto itB = MacroFilters.cbegin();
-  const auto itE = MacroFilters.cend();
+  const auto itB = this->MacroFilters.cbegin();
+  const auto itE = this->MacroFilters.cend();
   const auto itL = itE - 1;
   auto itC = itB;
   for (; itC != itE; ++itC) {
@@ -768,30 +769,31 @@ std::string cmQtAutoMocUicT::MocSettingsT::MacrosString() const
 
 cmQtAutoMocUicT::UicSettingsT::UicSettingsT()
 {
-  RegExpInclude.compile("(^|\n)[ \t]*#[ \t]*include[ \t]+"
-                        "[\"<](([^ \">]+/)?ui_[^ \">/]+\\.h)[\">]");
+  this->RegExpInclude.compile("(^|\n)[ \t]*#[ \t]*include[ \t]+"
+                              "[\"<](([^ \">]+/)?ui_[^ \">/]+\\.h)[\">]");
 }
 
 cmQtAutoMocUicT::UicSettingsT::~UicSettingsT() = default;
 
 bool cmQtAutoMocUicT::UicSettingsT::skipped(std::string const& fileName) const
 {
-  return (!Enabled || (SkipList.find(fileName) != SkipList.end()));
+  return (!this->Enabled ||
+          (this->SkipList.find(fileName) != this->SkipList.end()));
 }
 
 void cmQtAutoMocUicT::JobT::LogError(GenT genType,
                                      cm::string_view message) const
 {
-  Gen()->AbortError();
-  Gen()->Log().Error(genType, message);
+  this->Gen()->AbortError();
+  this->Gen()->Log().Error(genType, message);
 }
 
 void cmQtAutoMocUicT::JobT::LogCommandError(
   GenT genType, cm::string_view message,
   std::vector<std::string> const& command, std::string const& output) const
 {
-  Gen()->AbortError();
-  Gen()->Log().ErrorCommand(genType, message, command, output);
+  this->Gen()->AbortError();
+  this->Gen()->Log().ErrorCommand(genType, message, command, output);
 }
 
 bool cmQtAutoMocUicT::JobT::RunProcess(GenT genType,
@@ -800,48 +802,48 @@ bool cmQtAutoMocUicT::JobT::RunProcess(GenT genType,
                                        std::string* infoMessage)
 {
   // Log command
-  if (Log().Verbose()) {
+  if (this->Log().Verbose()) {
     cm::string_view info;
     if (infoMessage != nullptr) {
       info = *infoMessage;
     }
-    Log().Info(genType,
-               cmStrCat(info,
-                        info.empty() || cmHasSuffix(info, '\n') ? "" : "\n",
-                        QuotedCommand(command), '\n'));
+    this->Log().Info(
+      genType,
+      cmStrCat(info, info.empty() || cmHasSuffix(info, '\n') ? "" : "\n",
+               QuotedCommand(command), '\n'));
   }
   // Run command
-  return cmWorkerPool::JobT::RunProcess(result, command,
-                                        BaseConst().AutogenBuildDir);
+  return this->cmWorkerPool::JobT::RunProcess(
+    result, command, this->BaseConst().AutogenBuildDir);
 }
 
 void cmQtAutoMocUicT::JobMocPredefsT::Process()
 {
   // (Re)generate moc_predefs.h on demand
   std::unique_ptr<std::string> reason;
-  if (Log().Verbose()) {
+  if (this->Log().Verbose()) {
     reason = cm::make_unique<std::string>();
   }
-  if (!Update(reason.get())) {
+  if (!this->Update(reason.get())) {
     return;
   }
-  std::string const& predefsFileAbs = MocConst().PredefsFileAbs;
+  std::string const& predefsFileAbs = this->MocConst().PredefsFileAbs;
   {
     cmWorkerPool::ProcessResultT result;
     {
       // Compose command
-      std::vector<std::string> cmd = MocConst().PredefsCmd;
+      std::vector<std::string> cmd = this->MocConst().PredefsCmd;
       // Add definitions
-      cm::append(cmd, MocConst().OptionsDefinitions);
+      cm::append(cmd, this->MocConst().OptionsDefinitions);
       // Add includes
-      cm::append(cmd, MocConst().OptionsIncludes);
+      cm::append(cmd, this->MocConst().OptionsIncludes);
       // Execute command
-      if (!RunProcess(GenT::MOC, result, cmd, reason.get())) {
-        LogCommandError(GenT::MOC,
-                        cmStrCat("The content generation command for ",
-                                 MessagePath(predefsFileAbs), " failed.\n",
-                                 result.ErrorMessage),
-                        cmd, result.StdOut);
+      if (!this->RunProcess(GenT::MOC, result, cmd, reason.get())) {
+        this->LogCommandError(GenT::MOC,
+                              cmStrCat("The content generation command for ",
+                                       this->MessagePath(predefsFileAbs),
+                                       " failed.\n", result.ErrorMessage),
+                              cmd, result.StdOut);
         return;
       }
     }
@@ -849,30 +851,31 @@ void cmQtAutoMocUicT::JobMocPredefsT::Process()
     // (Re)write predefs file only on demand
     if (cmQtAutoGenerator::FileDiffers(predefsFileAbs, result.StdOut)) {
       if (!cmQtAutoGenerator::FileWrite(predefsFileAbs, result.StdOut)) {
-        LogError(
+        this->LogError(
           GenT::MOC,
-          cmStrCat("Writing ", MessagePath(predefsFileAbs), " failed."));
+          cmStrCat("Writing ", this->MessagePath(predefsFileAbs), " failed."));
         return;
       }
     } else {
       // Touch to update the time stamp
-      if (Log().Verbose()) {
-        Log().Info(GenT::MOC, "Touching " + MessagePath(predefsFileAbs));
+      if (this->Log().Verbose()) {
+        this->Log().Info(GenT::MOC,
+                         "Touching " + this->MessagePath(predefsFileAbs));
       }
       if (!cmSystemTools::Touch(predefsFileAbs, false)) {
-        LogError(
-          GenT::MOC,
-          cmStrCat("Touching ", MessagePath(predefsFileAbs), " failed."));
+        this->LogError(GenT::MOC,
+                       cmStrCat("Touching ", this->MessagePath(predefsFileAbs),
+                                " failed."));
         return;
       }
     }
   }
 
   // Read file time afterwards
-  if (!MocEval().PredefsTime.Load(predefsFileAbs)) {
-    LogError(GenT::MOC,
-             cmStrCat("Reading the file time of ", MessagePath(predefsFileAbs),
-                      " failed."));
+  if (!this->MocEval().PredefsTime.Load(predefsFileAbs)) {
+    this->LogError(GenT::MOC,
+                   cmStrCat("Reading the file time of ",
+                            this->MessagePath(predefsFileAbs), " failed."));
     return;
   }
 }
@@ -880,18 +883,20 @@ void cmQtAutoMocUicT::JobMocPredefsT::Process()
 bool cmQtAutoMocUicT::JobMocPredefsT::Update(std::string* reason) const
 {
   // Test if the file exists
-  if (!MocEval().PredefsTime.Load(MocConst().PredefsFileAbs)) {
+  if (!this->MocEval().PredefsTime.Load(this->MocConst().PredefsFileAbs)) {
     if (reason != nullptr) {
-      *reason = cmStrCat("Generating ", MessagePath(MocConst().PredefsFileAbs),
+      *reason = cmStrCat("Generating ",
+                         this->MessagePath(this->MocConst().PredefsFileAbs),
                          ", because it doesn't exist.");
     }
     return true;
   }
 
   // Test if the settings changed
-  if (MocConst().SettingsChanged) {
+  if (this->MocConst().SettingsChanged) {
     if (reason != nullptr) {
-      *reason = cmStrCat("Generating ", MessagePath(MocConst().PredefsFileAbs),
+      *reason = cmStrCat("Generating ",
+                         this->MessagePath(this->MocConst().PredefsFileAbs),
                          ", because the moc settings changed.");
     }
     return true;
@@ -899,14 +904,14 @@ bool cmQtAutoMocUicT::JobMocPredefsT::Update(std::string* reason) const
 
   // Test if the executable is newer
   {
-    std::string const& exec = MocConst().PredefsCmd.at(0);
+    std::string const& exec = this->MocConst().PredefsCmd.at(0);
     cmFileTime execTime;
     if (execTime.Load(exec)) {
-      if (MocEval().PredefsTime.Older(execTime)) {
+      if (this->MocEval().PredefsTime.Older(execTime)) {
         if (reason != nullptr) {
-          *reason =
-            cmStrCat("Generating ", MessagePath(MocConst().PredefsFileAbs),
-                     " because it is older than ", MessagePath(exec), '.');
+          *reason = cmStrCat(
+            "Generating ", this->MessagePath(this->MocConst().PredefsFileAbs),
+            " because it is older than ", this->MessagePath(exec), '.');
         }
         return true;
       }
@@ -919,25 +924,27 @@ bool cmQtAutoMocUicT::JobMocPredefsT::Update(std::string* reason) const
 bool cmQtAutoMocUicT::JobParseT::ReadFile()
 {
   // Clear old parse information
-  FileHandle->ParseData->Clear();
-  std::string const& fileName = FileHandle->FileName;
+  this->FileHandle->ParseData->Clear();
+  std::string const& fileName = this->FileHandle->FileName;
   // Write info
-  if (Log().Verbose()) {
-    Log().Info(GenT::GEN, cmStrCat("Parsing ", MessagePath(fileName)));
+  if (this->Log().Verbose()) {
+    this->Log().Info(GenT::GEN,
+                     cmStrCat("Parsing ", this->MessagePath(fileName)));
   }
   // Read file content
   {
     std::string error;
-    if (!cmQtAutoGenerator::FileRead(Content, fileName, &error)) {
-      LogError(
-        GenT::GEN,
-        cmStrCat("Could not read ", MessagePath(fileName), ".\n", error));
+    if (!cmQtAutoGenerator::FileRead(this->Content, fileName, &error)) {
+      this->LogError(GenT::GEN,
+                     cmStrCat("Could not read ", this->MessagePath(fileName),
+                              ".\n", error));
       return false;
     }
   }
   // Warn if empty
-  if (Content.empty()) {
-    Log().Warning(GenT::GEN, cmStrCat(MessagePath(fileName), " is empty."));
+  if (this->Content.empty()) {
+    this->Log().Warning(GenT::GEN,
+                        cmStrCat(this->MessagePath(fileName), " is empty."));
     return false;
   }
   return true;
@@ -958,16 +965,16 @@ void cmQtAutoMocUicT::JobParseT::CreateKeys(
 
 void cmQtAutoMocUicT::JobParseT::MocMacro()
 {
-  for (KeyExpT const& filter : MocConst().MacroFilters) {
+  for (KeyExpT const& filter : this->MocConst().MacroFilters) {
     // Run a simple find string check
-    if (Content.find(filter.Key) == std::string::npos) {
+    if (this->Content.find(filter.Key) == std::string::npos) {
       continue;
     }
     // Run the expensive regular expression check loop
     cmsys::RegularExpressionMatch match;
-    if (filter.Exp.find(Content.c_str(), match)) {
+    if (filter.Exp.find(this->Content.c_str(), match)) {
       // Keep detected macro name
-      FileHandle->ParseData->Moc.Macro = filter.Key;
+      this->FileHandle->ParseData->Moc.Macro = filter.Key;
       return;
     }
   }
@@ -975,19 +982,20 @@ void cmQtAutoMocUicT::JobParseT::MocMacro()
 
 void cmQtAutoMocUicT::JobParseT::MocDependecies()
 {
-  if (MocConst().DependFilters.empty() || MocConst().CanOutputDependencies) {
+  if (this->MocConst().DependFilters.empty() ||
+      this->MocConst().CanOutputDependencies) {
     return;
   }
 
   // Find dependency strings
   std::set<std::string> parseDepends;
-  for (KeyExpT const& filter : MocConst().DependFilters) {
+  for (KeyExpT const& filter : this->MocConst().DependFilters) {
     // Run a simple find string check
-    if (Content.find(filter.Key) == std::string::npos) {
+    if (this->Content.find(filter.Key) == std::string::npos) {
       continue;
     }
     // Run the expensive regular expression check loop
-    const char* contentChars = Content.c_str();
+    const char* contentChars = this->Content.c_str();
     cmsys::RegularExpressionMatch match;
     while (filter.Exp.find(contentChars, match)) {
       {
@@ -1002,7 +1010,7 @@ void cmQtAutoMocUicT::JobParseT::MocDependecies()
 
   // Store dependency strings
   {
-    auto& Depends = FileHandle->ParseData->Moc.Depends;
+    auto& Depends = this->FileHandle->ParseData->Moc.Depends;
     Depends.reserve(parseDepends.size());
     for (std::string const& item : parseDepends) {
       Depends.emplace_back(item);
@@ -1016,15 +1024,15 @@ void cmQtAutoMocUicT::JobParseT::MocDependecies()
 
 void cmQtAutoMocUicT::JobParseT::MocIncludes()
 {
-  if (Content.find("moc") == std::string::npos) {
+  if (this->Content.find("moc") == std::string::npos) {
     return;
   }
 
   std::set<std::string> underscore;
   std::set<std::string> dot;
   {
-    const char* contentChars = Content.c_str();
-    cmsys::RegularExpression const& regExp = MocConst().RegExpInclude;
+    const char* contentChars = this->Content.c_str();
+    cmsys::RegularExpression const& regExp = this->MocConst().RegExpInclude;
     cmsys::RegularExpressionMatch match;
     while (regExp.find(contentChars, match)) {
       std::string incString = match.match(2);
@@ -1042,21 +1050,21 @@ void cmQtAutoMocUicT::JobParseT::MocIncludes()
       contentChars += match.end();
     }
   }
-  auto& Include = FileHandle->ParseData->Moc.Include;
-  CreateKeys(Include.Underscore, underscore, MocUnderscoreLength);
-  CreateKeys(Include.Dot, dot, 0);
+  auto& Include = this->FileHandle->ParseData->Moc.Include;
+  this->CreateKeys(Include.Underscore, underscore, MocUnderscoreLength);
+  this->CreateKeys(Include.Dot, dot, 0);
 }
 
 void cmQtAutoMocUicT::JobParseT::UicIncludes()
 {
-  if (Content.find("ui_") == std::string::npos) {
+  if (this->Content.find("ui_") == std::string::npos) {
     return;
   }
 
   std::set<std::string> includes;
   {
-    const char* contentChars = Content.c_str();
-    cmsys::RegularExpression const& regExp = UicConst().RegExpInclude;
+    const char* contentChars = this->Content.c_str();
+    cmsys::RegularExpression const& regExp = this->UicConst().RegExpInclude;
     cmsys::RegularExpressionMatch match;
     while (regExp.find(contentChars, match)) {
       includes.emplace(match.match(2));
@@ -1064,39 +1072,40 @@ void cmQtAutoMocUicT::JobParseT::UicIncludes()
       contentChars += match.end();
     }
   }
-  CreateKeys(FileHandle->ParseData->Uic.Include, includes, UiUnderscoreLength);
+  this->CreateKeys(this->FileHandle->ParseData->Uic.Include, includes,
+                   UiUnderscoreLength);
 }
 
 void cmQtAutoMocUicT::JobParseHeaderT::Process()
 {
-  if (!ReadFile()) {
+  if (!this->ReadFile()) {
     return;
   }
   // Moc parsing
-  if (FileHandle->Moc) {
-    MocMacro();
-    MocDependecies();
+  if (this->FileHandle->Moc) {
+    this->MocMacro();
+    this->MocDependecies();
   }
   // Uic parsing
-  if (FileHandle->Uic) {
-    UicIncludes();
+  if (this->FileHandle->Uic) {
+    this->UicIncludes();
   }
 }
 
 void cmQtAutoMocUicT::JobParseSourceT::Process()
 {
-  if (!ReadFile()) {
+  if (!this->ReadFile()) {
     return;
   }
   // Moc parsing
-  if (FileHandle->Moc) {
-    MocMacro();
-    MocDependecies();
-    MocIncludes();
+  if (this->FileHandle->Moc) {
+    this->MocMacro();
+    this->MocDependecies();
+    this->MocIncludes();
   }
   // Uic parsing
-  if (FileHandle->Uic) {
-    UicIncludes();
+  if (this->FileHandle->Uic) {
+    this->UicIncludes();
   }
 }
 
@@ -1104,9 +1113,9 @@ std::string cmQtAutoMocUicT::JobEvalCacheT::MessageSearchLocations() const
 {
   std::string res;
   res.reserve(512);
-  for (std::string const& path : SearchLocations) {
+  for (std::string const& path : this->SearchLocations) {
     res += "  ";
-    res += MessagePath(path);
+    res += this->MessagePath(path);
     res += '\n';
   }
   return res;
@@ -1115,14 +1124,14 @@ std::string cmQtAutoMocUicT::JobEvalCacheT::MessageSearchLocations() const
 void cmQtAutoMocUicT::JobEvalCacheMocT::Process()
 {
   // Evaluate headers
-  for (auto const& pair : BaseEval().Headers) {
-    if (!EvalHeader(pair.second)) {
+  for (auto const& pair : this->BaseEval().Headers) {
+    if (!this->EvalHeader(pair.second)) {
       return;
     }
   }
   // Evaluate sources
-  for (auto const& pair : BaseEval().Sources) {
-    if (!EvalSource(pair.second)) {
+  for (auto const& pair : this->BaseEval().Sources) {
+    if (!this->EvalSource(pair.second)) {
       return;
     }
   }
@@ -1142,14 +1151,16 @@ bool cmQtAutoMocUicT::JobEvalCacheMocT::EvalHeader(SourceFileHandleT source)
     handle->SourceFile = std::move(source);
 
     // Absolute build path
-    if (BaseConst().MultiConfig) {
-      handle->OutputFile = Gen()->AbsoluteIncludePath(sourceFile.BuildPath);
+    if (this->BaseConst().MultiConfig) {
+      handle->OutputFile =
+        this->Gen()->AbsoluteIncludePath(sourceFile.BuildPath);
     } else {
-      handle->OutputFile = Gen()->AbsoluteBuildPath(sourceFile.BuildPath);
+      handle->OutputFile =
+        this->Gen()->AbsoluteBuildPath(sourceFile.BuildPath);
     }
 
     // Register mapping in headers map
-    RegisterMapping(handle);
+    this->RegisterMapping(handle);
   }
 
   return true;
@@ -1171,7 +1182,7 @@ bool cmQtAutoMocUicT::JobEvalCacheMocT::EvalSource(
     cmSystemTools::GetFilenameWithoutLastExtension(sourceFile.FileName);
 
   // For relaxed mode check if the own "moc_" or ".moc" file is included
-  bool const relaxedMode = MocConst().RelaxedMode;
+  bool const relaxedMode = this->MocConst().RelaxedMode;
   bool sourceIncludesMocUnderscore = false;
   bool sourceIncludesDotMoc = false;
   // Check if the sources own "moc_" or ".moc" file is included
@@ -1193,12 +1204,13 @@ bool cmQtAutoMocUicT::JobEvalCacheMocT::EvalSource(
   // Check if this source needs to be moc processed but doesn't.
   if (!sourceIncludesDotMoc && !parseData.Macro.empty() &&
       !(relaxedMode && sourceIncludesMocUnderscore)) {
-    LogError(GenT::MOC,
-             cmStrCat(MessagePath(sourceFile.FileName), "\ncontains a ",
-                      Quoted(parseData.Macro), " macro, but does not include ",
-                      MessagePath(sourceBase + ".moc"),
-                      "!\nConsider to\n  - add #include \"", sourceBase,
-                      ".moc\"\n  - enable SKIP_AUTOMOC for this file"));
+    this->LogError(GenT::MOC,
+                   cmStrCat(this->MessagePath(sourceFile.FileName),
+                            "\ncontains a ", Quoted(parseData.Macro),
+                            " macro, but does not include ",
+                            this->MessagePath(sourceBase + ".moc"),
+                            "!\nConsider to\n  - add #include \"", sourceBase,
+                            ".moc\"\n  - enable SKIP_AUTOMOC for this file"));
     return false;
   }
 
@@ -1207,14 +1219,16 @@ bool cmQtAutoMocUicT::JobEvalCacheMocT::EvalSource(
     SourceFileHandleT headerHandle;
     {
       std::string const headerBase = cmStrCat(incKey.Dir, incKey.Base);
-      if (!FindIncludedHeader(headerHandle, sourceDirPrefix, headerBase)) {
-        LogError(GenT::MOC,
-                 cmStrCat(MessagePath(sourceFile.FileName),
-                          "\nincludes the moc file ", MessagePath(incKey.Key),
-                          ",\nbut a header ", MessageHeader(headerBase),
-                          "\ncould not be found "
-                          "in the following directories\n",
-                          MessageSearchLocations()));
+      if (!this->FindIncludedHeader(headerHandle, sourceDirPrefix,
+                                    headerBase)) {
+        this->LogError(
+          GenT::MOC,
+          cmStrCat(this->MessagePath(sourceFile.FileName),
+                   "\nincludes the moc file ", this->MessagePath(incKey.Key),
+                   ",\nbut a header ", this->MessageHeader(headerBase),
+                   "\ncould not be found "
+                   "in the following directories\n",
+                   this->MessageSearchLocations()));
         return false;
       }
     }
@@ -1228,30 +1242,31 @@ bool cmQtAutoMocUicT::JobEvalCacheMocT::EvalSource(
       // used. This is for KDE4 compatibility.
 
       // Issue a warning
-      Log().Warning(
+      this->Log().Warning(
         GenT::MOC,
-        cmStrCat(MessagePath(sourceFile.FileName), "\ncontains a ",
+        cmStrCat(this->MessagePath(sourceFile.FileName), "\ncontains a ",
                  Quoted(parseData.Macro), " macro, but does not include ",
-                 MessagePath(sourceBase + ".moc"), ".\nInstead it includes ",
-                 MessagePath(incKey.Key), ".\nRunning moc on the source\n  ",
-                 MessagePath(sourceFile.FileName), "!\nBetter include ",
-                 MessagePath(sourceBase + ".moc"),
+                 this->MessagePath(sourceBase + ".moc"),
+                 ".\nInstead it includes ", this->MessagePath(incKey.Key),
+                 ".\nRunning moc on the source\n  ",
+                 this->MessagePath(sourceFile.FileName), "!\nBetter include ",
+                 this->MessagePath(sourceBase + ".moc"),
                  " for compatibility with regular mode.\n",
                  "This is a CMAKE_AUTOMOC_RELAXED_MODE warning.\n"));
 
       // Create mapping
-      if (!RegisterIncluded(incKey.Key, source, source)) {
+      if (!this->RegisterIncluded(incKey.Key, source, source)) {
         return false;
       }
       continue;
     }
 
     // Check if header is skipped
-    if (MocConst().skipped(headerHandle->FileName)) {
+    if (this->MocConst().skipped(headerHandle->FileName)) {
       continue;
     }
     // Create mapping
-    if (!RegisterIncluded(incKey.Key, source, std::move(headerHandle))) {
+    if (!this->RegisterIncluded(incKey.Key, source, std::move(headerHandle))) {
       return false;
     }
   }
@@ -1264,7 +1279,7 @@ bool cmQtAutoMocUicT::JobEvalCacheMocT::EvalSource(
       bool const ownMoc = (incKey.Base == sourceBase);
       if (ownMoc && !parseData.Macro.empty()) {
         // Create mapping for the regular use case
-        if (!RegisterIncluded(incKey.Key, source, source)) {
+        if (!this->RegisterIncluded(incKey.Key, source, source)) {
           return false;
         }
         continue;
@@ -1274,50 +1289,54 @@ bool cmQtAutoMocUicT::JobEvalCacheMocT::EvalSource(
       SourceFileHandleT headerHandle;
       {
         std::string const headerBase = cmStrCat(incKey.Dir, incKey.Base);
-        if (!FindIncludedHeader(headerHandle, sourceDirPrefix, headerBase)) {
-          LogError(
+        if (!this->FindIncludedHeader(headerHandle, sourceDirPrefix,
+                                      headerBase)) {
+          this->LogError(
             GenT::MOC,
             cmStrCat(
-              MessagePath(sourceFile.FileName), "\nincludes the moc file ",
-              MessagePath(incKey.Key),
+              this->MessagePath(sourceFile.FileName),
+              "\nincludes the moc file ", this->MessagePath(incKey.Key),
               ",\nwhich seems to be the moc file from a different source "
               "file.\nCMAKE_AUTOMOC_RELAXED_MODE:\nAlso a matching header ",
-              MessageHeader(headerBase),
+              this->MessageHeader(headerBase),
               "\ncould not be found in the following directories\n",
-              MessageSearchLocations()));
+              this->MessageSearchLocations()));
           return false;
         }
       }
       // Check if header is skipped
-      if (MocConst().skipped(headerHandle->FileName)) {
+      if (this->MocConst().skipped(headerHandle->FileName)) {
         continue;
       }
       // Issue a warning
       if (ownMoc && parseData.Macro.empty()) {
-        Log().Warning(
+        this->Log().Warning(
           GenT::MOC,
-          cmStrCat(MessagePath(sourceFile.FileName),
-                   "\nincludes the moc file ", MessagePath(incKey.Key),
-                   ", but does not contain a\n", MocConst().MacrosString(),
-                   " macro.\nRunning moc on the header\n  ",
-                   MessagePath(headerHandle->FileName), "!\nBetter include ",
-                   MessagePath("moc_" + incKey.Base + ".cpp"),
-                   " for a compatibility with regular mode.\n",
-                   "This is a CMAKE_AUTOMOC_RELAXED_MODE warning.\n"));
+          cmStrCat(
+            this->MessagePath(sourceFile.FileName), "\nincludes the moc file ",
+            this->MessagePath(incKey.Key), ", but does not contain a\n",
+            this->MocConst().MacrosString(),
+            " macro.\nRunning moc on the header\n  ",
+            this->MessagePath(headerHandle->FileName), "!\nBetter include ",
+            this->MessagePath("moc_" + incKey.Base + ".cpp"),
+            " for a compatibility with regular mode.\n",
+            "This is a CMAKE_AUTOMOC_RELAXED_MODE warning.\n"));
       } else {
-        Log().Warning(
+        this->Log().Warning(
           GenT::MOC,
-          cmStrCat(MessagePath(sourceFile.FileName),
-                   "\nincludes the moc file ", MessagePath(incKey.Key),
-                   " instead of ", MessagePath("moc_" + incKey.Base + ".cpp"),
-                   ".\nRunning moc on the header\n  ",
-                   MessagePath(headerHandle->FileName), "!\nBetter include ",
-                   MessagePath("moc_" + incKey.Base + ".cpp"),
-                   " for compatibility with regular mode.\n",
-                   "This is a CMAKE_AUTOMOC_RELAXED_MODE warning.\n"));
+          cmStrCat(
+            this->MessagePath(sourceFile.FileName), "\nincludes the moc file ",
+            this->MessagePath(incKey.Key), " instead of ",
+            this->MessagePath("moc_" + incKey.Base + ".cpp"),
+            ".\nRunning moc on the header\n  ",
+            this->MessagePath(headerHandle->FileName), "!\nBetter include ",
+            this->MessagePath("moc_" + incKey.Base + ".cpp"),
+            " for compatibility with regular mode.\n",
+            "This is a CMAKE_AUTOMOC_RELAXED_MODE warning.\n"));
       }
       // Create mapping
-      if (!RegisterIncluded(incKey.Key, source, std::move(headerHandle))) {
+      if (!this->RegisterIncluded(incKey.Key, source,
+                                  std::move(headerHandle))) {
         return false;
       }
     }
@@ -1328,26 +1347,27 @@ bool cmQtAutoMocUicT::JobEvalCacheMocT::EvalSource(
       bool const ownMoc = (incKey.Base == sourceBase);
       if (!ownMoc) {
         // Don't allow <BASE>.moc include other than own in regular mode
-        LogError(GenT::MOC,
-                 cmStrCat(MessagePath(sourceFile.FileName),
-                          "\nincludes the moc file ", MessagePath(incKey.Key),
-                          ",\nwhich seems to be the moc file from a different "
-                          "source file.\nThis is not supported.  Include ",
-                          MessagePath(sourceBase + ".moc"),
-                          " to run moc on this source file."));
+        this->LogError(
+          GenT::MOC,
+          cmStrCat(this->MessagePath(sourceFile.FileName),
+                   "\nincludes the moc file ", this->MessagePath(incKey.Key),
+                   ",\nwhich seems to be the moc file from a different "
+                   "source file.\nThis is not supported.  Include ",
+                   this->MessagePath(sourceBase + ".moc"),
+                   " to run moc on this source file."));
         return false;
       }
       // Accept but issue a warning if moc isn't required
       if (parseData.Macro.empty()) {
-        Log().Warning(GenT::MOC,
-                      cmStrCat(MessagePath(sourceFile.FileName),
-                               "\nincludes the moc file ",
-                               MessagePath(incKey.Key),
-                               ", but does not contain a ",
-                               MocConst().MacrosString(), " macro."));
+        this->Log().Warning(
+          GenT::MOC,
+          cmStrCat(this->MessagePath(sourceFile.FileName),
+                   "\nincludes the moc file ", this->MessagePath(incKey.Key),
+                   ", but does not contain a ",
+                   this->MocConst().MacrosString(), " macro."));
       }
       // Create mapping
-      if (!RegisterIncluded(incKey.Key, source, source)) {
+      if (!this->RegisterIncluded(incKey.Key, source, source)) {
         return false;
       }
     }
@@ -1361,7 +1381,7 @@ bool cmQtAutoMocUicT::JobEvalCacheMocT::FindIncludedHeader(
   cm::string_view includeBase)
 {
   // Clear search locations
-  SearchLocations.clear();
+  this->SearchLocations.clear();
 
   auto findHeader = [this,
                      &headerHandle](std::string const& basePath) -> bool {
@@ -1377,8 +1397,8 @@ bool cmQtAutoMocUicT::JobEvalCacheMocT::FindIncludedHeader(
 
       // Return a known file if it exists already
       {
-        auto it = BaseEval().Headers.find(testPath);
-        if (it != BaseEval().Headers.end()) {
+        auto it = this->BaseEval().Headers.find(testPath);
+        if (it != this->BaseEval().Headers.end()) {
           headerHandle = it->second;
           found = true;
           break;
@@ -1387,7 +1407,8 @@ bool cmQtAutoMocUicT::JobEvalCacheMocT::FindIncludedHeader(
 
       // Created and return discovered file entry
       {
-        SourceFileHandleT& handle = MocEval().HeadersDiscovered[testPath];
+        SourceFileHandleT& handle =
+          this->MocEval().HeadersDiscovered[testPath];
         if (!handle) {
           handle = std::make_shared<SourceFileT>(testPath);
           handle->FileTime = fileTime;
@@ -1410,7 +1431,7 @@ bool cmQtAutoMocUicT::JobEvalCacheMocT::FindIncludedHeader(
     return true;
   }
   // Search in include directories
-  for (std::string const& path : MocConst().IncludePaths) {
+  for (std::string const& path : this->MocConst().IncludePaths) {
     if (findHeader(cmStrCat(path, '/', includeBase))) {
       return true;
     }
@@ -1424,24 +1445,24 @@ bool cmQtAutoMocUicT::JobEvalCacheMocT::RegisterIncluded(
   SourceFileHandleT sourceFileHandle) const
 {
   // Check if this file is already included
-  MappingHandleT& handle = MocEval().Includes[includeString];
+  MappingHandleT& handle = this->MocEval().Includes[includeString];
   if (handle) {
     // Check if the output file would be generated from different source files
     if (handle->SourceFile != sourceFileHandle) {
       std::string files =
-        cmStrCat("  ", MessagePath(includerFileHandle->FileName), '\n');
+        cmStrCat("  ", this->MessagePath(includerFileHandle->FileName), '\n');
       for (auto const& item : handle->IncluderFiles) {
-        files += cmStrCat("  ", MessagePath(item->FileName), '\n');
+        files += cmStrCat("  ", this->MessagePath(item->FileName), '\n');
       }
-      LogError(
+      this->LogError(
         GenT::MOC,
         cmStrCat("The source files\n", files,
                  "contain the same include string ",
-                 MessagePath(includeString),
+                 this->MessagePath(includeString),
                  ", but\nthe moc file would be generated from different "
                  "source files\n  ",
-                 MessagePath(sourceFileHandle->FileName), " and\n  ",
-                 MessagePath(handle->SourceFile->FileName),
+                 this->MessagePath(sourceFileHandle->FileName), " and\n  ",
+                 this->MessagePath(handle->SourceFile->FileName),
                  ".\nConsider to\n"
                  "  - not include the \"moc_<NAME>.cpp\" file\n"
                  "  - add a directory prefix to a \"<NAME>.moc\" include "
@@ -1460,10 +1481,10 @@ bool cmQtAutoMocUicT::JobEvalCacheMocT::RegisterIncluded(
   handle->IncludeString = includeString;
   handle->IncluderFiles.emplace_back(std::move(includerFileHandle));
   handle->SourceFile = std::move(sourceFileHandle);
-  handle->OutputFile = Gen()->AbsoluteIncludePath(includeString);
+  handle->OutputFile = this->Gen()->AbsoluteIncludePath(includeString);
 
   // Register mapping in sources/headers map
-  RegisterMapping(handle);
+  this->RegisterMapping(handle);
   return true;
 }
 
@@ -1471,8 +1492,8 @@ void cmQtAutoMocUicT::JobEvalCacheMocT::RegisterMapping(
   MappingHandleT mappingHandle) const
 {
   auto& regMap = mappingHandle->SourceFile->IsHeader
-    ? MocEval().HeaderMappings
-    : MocEval().SourceMappings;
+    ? this->MocEval().HeaderMappings
+    : this->MocEval().SourceMappings;
   // Check if source file already gets mapped
   auto& regHandle = regMap[mappingHandle->SourceFile->FileName];
   if (!regHandle) {
@@ -1489,24 +1510,24 @@ void cmQtAutoMocUicT::JobEvalCacheMocT::RegisterMapping(
 std::string cmQtAutoMocUicT::JobEvalCacheMocT::MessageHeader(
   cm::string_view headerBase) const
 {
-  return MessagePath(cmStrCat(
+  return this->MessagePath(cmStrCat(
     headerBase, ".{", cmJoin(this->BaseConst().HeaderExtensions, ","), '}'));
 }
 
 void cmQtAutoMocUicT::JobEvalCacheUicT::Process()
 {
   // Prepare buffers
-  SearchLocations.reserve((UicConst().SearchPaths.size() + 1) * 2);
+  this->SearchLocations.reserve((this->UicConst().SearchPaths.size() + 1) * 2);
 
   // Evaluate headers
-  for (auto const& pair : BaseEval().Headers) {
-    if (!EvalFile(pair.second)) {
+  for (auto const& pair : this->BaseEval().Headers) {
+    if (!this->EvalFile(pair.second)) {
       return;
     }
   }
   // Evaluate sources
-  for (auto const& pair : BaseEval().Sources) {
-    if (!EvalFile(pair.second)) {
+  for (auto const& pair : this->BaseEval().Sources) {
+    if (!this->EvalFile(pair.second)) {
       return;
     }
   }
@@ -1524,22 +1545,24 @@ bool cmQtAutoMocUicT::JobEvalCacheUicT::EvalFile(
   std::string const sourceDirPrefix = SubDirPrefix(sourceFile.FileName);
   for (IncludeKeyT const& incKey : Include) {
     // Find .ui file
-    UiName = cmStrCat(incKey.Base, ".ui");
-    if (!FindIncludedUi(sourceDirPrefix, incKey.Dir)) {
-      LogError(GenT::UIC,
-               cmStrCat(MessagePath(sourceFile.FileName),
-                        "\nincludes the uic file ", MessagePath(incKey.Key),
-                        ",\nbut the user interface file ", MessagePath(UiName),
-                        "\ncould not be found in the following directories\n",
-                        MessageSearchLocations()));
+    this->UiName = cmStrCat(incKey.Base, ".ui");
+    if (!this->FindIncludedUi(sourceDirPrefix, incKey.Dir)) {
+      this->LogError(
+        GenT::UIC,
+        cmStrCat(this->MessagePath(sourceFile.FileName),
+                 "\nincludes the uic file ", this->MessagePath(incKey.Key),
+                 ",\nbut the user interface file ",
+                 this->MessagePath(this->UiName),
+                 "\ncould not be found in the following directories\n",
+                 this->MessageSearchLocations()));
       return false;
     }
     // Check if the file is skipped
-    if (UicConst().skipped(UiFileHandle->FileName)) {
+    if (this->UicConst().skipped(this->UiFileHandle->FileName)) {
       continue;
     }
     // Register mapping
-    if (!RegisterMapping(incKey.Key, sourceFileHandle)) {
+    if (!this->RegisterMapping(incKey.Key, sourceFileHandle)) {
       return false;
     }
   }
@@ -1551,7 +1574,7 @@ bool cmQtAutoMocUicT::JobEvalCacheUicT::FindIncludedUi(
   cm::string_view sourceDirPrefix, cm::string_view includePrefix)
 {
   // Clear locations buffer
-  SearchLocations.clear();
+  this->SearchLocations.clear();
 
   auto findUi = [this](std::string const& testPath) -> bool {
     std::string const fullPath = this->Gen()->CollapseFullPathTS(testPath);
@@ -1573,25 +1596,25 @@ bool cmQtAutoMocUicT::JobEvalCacheUicT::FindIncludedUi(
   };
 
   // Vicinity of the source
-  if (findUi(cmStrCat(sourceDirPrefix, UiName))) {
+  if (findUi(cmStrCat(sourceDirPrefix, this->UiName))) {
     return true;
   }
   if (!includePrefix.empty()) {
-    if (findUi(cmStrCat(sourceDirPrefix, includePrefix, UiName))) {
+    if (findUi(cmStrCat(sourceDirPrefix, includePrefix, this->UiName))) {
       return true;
     }
   }
   // Additional AUTOUIC search paths
-  auto const& searchPaths = UicConst().SearchPaths;
+  auto const& searchPaths = this->UicConst().SearchPaths;
   if (!searchPaths.empty()) {
     for (std::string const& sPath : searchPaths) {
-      if (findUi(cmStrCat(sPath, '/', UiName))) {
+      if (findUi(cmStrCat(sPath, '/', this->UiName))) {
         return true;
       }
     }
     if (!includePrefix.empty()) {
       for (std::string const& sPath : searchPaths) {
-        if (findUi(cmStrCat(sPath, '/', includePrefix, UiName))) {
+        if (findUi(cmStrCat(sPath, '/', includePrefix, this->UiName))) {
           return true;
         }
       }
@@ -1604,26 +1627,26 @@ bool cmQtAutoMocUicT::JobEvalCacheUicT::FindIncludedUi(
 bool cmQtAutoMocUicT::JobEvalCacheUicT::RegisterMapping(
   std::string const& includeString, SourceFileHandleT includerFileHandle)
 {
-  auto& Includes = Gen()->UicEval().Includes;
+  auto& Includes = this->Gen()->UicEval().Includes;
   auto it = Includes.find(includeString);
   if (it != Includes.end()) {
     MappingHandleT const& handle = it->second;
-    if (handle->SourceFile != UiFileHandle) {
+    if (handle->SourceFile != this->UiFileHandle) {
       // The output file already gets generated - from a different .ui file!
       std::string files =
-        cmStrCat("  ", MessagePath(includerFileHandle->FileName), '\n');
+        cmStrCat("  ", this->MessagePath(includerFileHandle->FileName), '\n');
       for (auto const& item : handle->IncluderFiles) {
-        files += cmStrCat("  ", MessagePath(item->FileName), '\n');
+        files += cmStrCat("  ", this->MessagePath(item->FileName), '\n');
       }
-      LogError(
+      this->LogError(
         GenT::UIC,
         cmStrCat(
           "The source files\n", files, "contain the same include string ",
           Quoted(includeString),
           ", but\nthe uic file would be generated from different "
           "user interface files\n  ",
-          MessagePath(UiFileHandle->FileName), " and\n  ",
-          MessagePath(handle->SourceFile->FileName),
+          this->MessagePath(this->UiFileHandle->FileName), " and\n  ",
+          this->MessagePath(handle->SourceFile->FileName),
           ".\nConsider to\n"
           "  - add a directory prefix to a \"ui_<NAME>.h\" include "
           "(e.g \"sub/ui_<NAME>.h\")\n"
@@ -1638,8 +1661,8 @@ bool cmQtAutoMocUicT::JobEvalCacheUicT::RegisterMapping(
     MappingHandleT handle = std::make_shared<MappingT>();
     handle->IncludeString = includeString;
     handle->IncluderFiles.emplace_back(std::move(includerFileHandle));
-    handle->SourceFile = UiFileHandle;
-    handle->OutputFile = Gen()->AbsoluteIncludePath(includeString);
+    handle->SourceFile = this->UiFileHandle;
+    handle->OutputFile = this->Gen()->AbsoluteIncludePath(includeString);
     // Register mapping
     Includes.emplace(includeString, std::move(handle));
   }
@@ -1649,40 +1672,42 @@ bool cmQtAutoMocUicT::JobEvalCacheUicT::RegisterMapping(
 void cmQtAutoMocUicT::JobEvalCacheFinishT::Process()
 {
   // Add discovered header parse jobs
-  Gen()->CreateParseJobs<JobParseHeaderT>(MocEval().HeadersDiscovered);
+  this->Gen()->CreateParseJobs<JobParseHeaderT>(
+    this->MocEval().HeadersDiscovered);
 
   // Add dependency probing jobs
   {
     // Add fence job to ensure all parsing has finished
-    Gen()->WorkerPool().EmplaceJob<JobFenceT>();
-    if (MocConst().Enabled) {
-      Gen()->WorkerPool().EmplaceJob<JobProbeDepsMocT>();
+    this->Gen()->WorkerPool().EmplaceJob<JobFenceT>();
+    if (this->MocConst().Enabled) {
+      this->Gen()->WorkerPool().EmplaceJob<JobProbeDepsMocT>();
     }
-    if (UicConst().Enabled) {
-      Gen()->WorkerPool().EmplaceJob<JobProbeDepsUicT>();
+    if (this->UicConst().Enabled) {
+      this->Gen()->WorkerPool().EmplaceJob<JobProbeDepsUicT>();
     }
     // Add probe finish job
-    Gen()->WorkerPool().EmplaceJob<JobProbeDepsFinishT>();
+    this->Gen()->WorkerPool().EmplaceJob<JobProbeDepsFinishT>();
   }
 }
 
 void cmQtAutoMocUicT::JobProbeDepsMocT::Process()
 {
   // Create moc header jobs
-  for (auto const& pair : MocEval().HeaderMappings) {
+  for (auto const& pair : this->MocEval().HeaderMappings) {
     // Register if this mapping is a candidate for mocs_compilation.cpp
     bool const compFile = pair.second->IncludeString.empty();
     if (compFile) {
-      MocEval().CompFiles.emplace_back(pair.second->SourceFile->BuildPath);
+      this->MocEval().CompFiles.emplace_back(
+        pair.second->SourceFile->BuildPath);
     }
-    if (!Generate(pair.second, compFile)) {
+    if (!this->Generate(pair.second, compFile)) {
       return;
     }
   }
 
   // Create moc source jobs
-  for (auto const& pair : MocEval().SourceMappings) {
-    if (!Generate(pair.second, false)) {
+  for (auto const& pair : this->MocEval().SourceMappings) {
+    if (!this->Generate(pair.second, false)) {
       return;
     }
   }
@@ -1692,22 +1717,23 @@ bool cmQtAutoMocUicT::JobProbeDepsMocT::Generate(MappingHandleT const& mapping,
                                                  bool compFile) const
 {
   std::unique_ptr<std::string> reason;
-  if (Log().Verbose()) {
+  if (this->Log().Verbose()) {
     reason = cm::make_unique<std::string>();
   }
-  if (Probe(*mapping, reason.get())) {
+  if (this->Probe(*mapping, reason.get())) {
     // Register the parent directory for creation
-    MocEval().OutputDirs.emplace(cmQtAutoGen::ParentDir(mapping->OutputFile));
+    this->MocEval().OutputDirs.emplace(
+      cmQtAutoGen::ParentDir(mapping->OutputFile));
     // Fetch the cache entry for the source file
     std::string const& sourceFile = mapping->SourceFile->FileName;
     ParseCacheT::GetOrInsertT cacheEntry =
-      BaseEval().ParseCache.GetOrInsert(sourceFile);
+      this->BaseEval().ParseCache.GetOrInsert(sourceFile);
     // Add moc job
-    Gen()->WorkerPool().EmplaceJob<JobCompileMocT>(
+    this->Gen()->WorkerPool().EmplaceJob<JobCompileMocT>(
       mapping, std::move(reason), std::move(cacheEntry.first));
     // Check if a moc job for a mocs_compilation.cpp entry was generated
     if (compFile) {
-      MocEval().CompUpdated = true;
+      this->MocEval().CompUpdated = true;
     }
   }
   return true;
@@ -1723,19 +1749,19 @@ bool cmQtAutoMocUicT::JobProbeDepsMocT::Probe(MappingT const& mapping,
   cmFileTime outputFileTime;
   if (!outputFileTime.Load(outputFile)) {
     if (reason != nullptr) {
-      *reason =
-        cmStrCat("Generating ", MessagePath(outputFile),
-                 ", because it doesn't exist, from ", MessagePath(sourceFile));
+      *reason = cmStrCat("Generating ", this->MessagePath(outputFile),
+                         ", because it doesn't exist, from ",
+                         this->MessagePath(sourceFile));
     }
     return true;
   }
 
   // Test if any setting changed
-  if (MocConst().SettingsChanged) {
+  if (this->MocConst().SettingsChanged) {
     if (reason != nullptr) {
-      *reason = cmStrCat("Generating ", MessagePath(outputFile),
+      *reason = cmStrCat("Generating ", this->MessagePath(outputFile),
                          ", because the uic settings changed, from ",
-                         MessagePath(sourceFile));
+                         this->MessagePath(sourceFile));
     }
     return true;
   }
@@ -1743,32 +1769,32 @@ bool cmQtAutoMocUicT::JobProbeDepsMocT::Probe(MappingT const& mapping,
   // Test if the source file is newer
   if (outputFileTime.Older(mapping.SourceFile->FileTime)) {
     if (reason != nullptr) {
-      *reason = cmStrCat("Generating ", MessagePath(outputFile),
+      *reason = cmStrCat("Generating ", this->MessagePath(outputFile),
                          ", because it's older than its source file, from ",
-                         MessagePath(sourceFile));
+                         this->MessagePath(sourceFile));
     }
     return true;
   }
 
   // Test if the moc_predefs file is newer
-  if (!MocConst().PredefsFileAbs.empty()) {
-    if (outputFileTime.Older(MocEval().PredefsTime)) {
+  if (!this->MocConst().PredefsFileAbs.empty()) {
+    if (outputFileTime.Older(this->MocEval().PredefsTime)) {
       if (reason != nullptr) {
-        *reason = cmStrCat("Generating ", MessagePath(outputFile),
+        *reason = cmStrCat("Generating ", this->MessagePath(outputFile),
                            ", because it's older than ",
-                           MessagePath(MocConst().PredefsFileAbs), ", from ",
-                           MessagePath(sourceFile));
+                           this->MessagePath(this->MocConst().PredefsFileAbs),
+                           ", from ", this->MessagePath(sourceFile));
       }
       return true;
     }
   }
 
   // Test if the moc executable is newer
-  if (outputFileTime.Older(MocConst().ExecutableTime)) {
+  if (outputFileTime.Older(this->MocConst().ExecutableTime)) {
     if (reason != nullptr) {
-      *reason = cmStrCat("Generating ", MessagePath(outputFile),
+      *reason = cmStrCat("Generating ", this->MessagePath(outputFile),
                          ", because it's older than the moc executable, from ",
-                         MessagePath(sourceFile));
+                         this->MessagePath(sourceFile));
     }
     return true;
   }
@@ -1782,26 +1808,26 @@ bool cmQtAutoMocUicT::JobProbeDepsMocT::Probe(MappingT const& mapping,
       auto& dep = *it;
 
       // Find dependency file
-      auto const depMatch = FindDependency(sourceDir, dep);
+      auto const depMatch = this->FindDependency(sourceDir, dep);
       if (depMatch.first.empty()) {
         if (reason != nullptr) {
-          *reason =
-            cmStrCat("Generating ", MessagePath(outputFile), " from ",
-                     MessagePath(sourceFile), ", because its dependency ",
-                     MessagePath(dep), " vanished.");
+          *reason = cmStrCat("Generating ", this->MessagePath(outputFile),
+                             " from ", this->MessagePath(sourceFile),
+                             ", because its dependency ",
+                             this->MessagePath(dep), " vanished.");
         }
         dependencies.erase(it);
-        BaseEval().ParseCacheChanged = true;
+        this->BaseEval().ParseCacheChanged = true;
         return true;
       }
 
       // Test if dependency file is older
       if (outputFileTime.Older(depMatch.second)) {
         if (reason != nullptr) {
-          *reason = cmStrCat("Generating ", MessagePath(outputFile),
+          *reason = cmStrCat("Generating ", this->MessagePath(outputFile),
                              ", because it's older than its dependency file ",
-                             MessagePath(depMatch.first), ", from ",
-                             MessagePath(sourceFile));
+                             this->MessagePath(depMatch.first), ", from ",
+                             this->MessagePath(sourceFile));
         }
         return true;
       }
@@ -1817,7 +1843,7 @@ cmQtAutoMocUicT::JobProbeDepsMocT::FindDependency(
 {
   using ResPair = std::pair<std::string, cmFileTime>;
   // moc's dependency file contains absolute paths
-  if (MocConst().CanOutputDependencies) {
+  if (this->MocConst().CanOutputDependencies) {
     ResPair res{ includeString, {} };
     if (res.second.Load(res.first)) {
       return res;
@@ -1832,7 +1858,7 @@ cmQtAutoMocUicT::JobProbeDepsMocT::FindDependency(
     }
   }
   // Search in include directories
-  for (std::string const& includePath : MocConst().IncludePaths) {
+  for (std::string const& includePath : this->MocConst().IncludePaths) {
     ResPair res{ cmStrCat(includePath, '/', includeString), {} };
     if (res.second.Load(res.first)) {
       return res;
@@ -1844,20 +1870,22 @@ cmQtAutoMocUicT::JobProbeDepsMocT::FindDependency(
 
 void cmQtAutoMocUicT::JobProbeDepsUicT::Process()
 {
-  for (auto const& pair : Gen()->UicEval().Includes) {
+  for (auto const& pair : this->Gen()->UicEval().Includes) {
     MappingHandleT const& mapping = pair.second;
     std::unique_ptr<std::string> reason;
-    if (Log().Verbose()) {
+    if (this->Log().Verbose()) {
       reason = cm::make_unique<std::string>();
     }
-    if (!Probe(*mapping, reason.get())) {
+    if (!this->Probe(*mapping, reason.get())) {
       continue;
     }
 
     // Register the parent directory for creation
-    UicEval().OutputDirs.emplace(cmQtAutoGen::ParentDir(mapping->OutputFile));
+    this->UicEval().OutputDirs.emplace(
+      cmQtAutoGen::ParentDir(mapping->OutputFile));
     // Add uic job
-    Gen()->WorkerPool().EmplaceJob<JobCompileUicT>(mapping, std::move(reason));
+    this->Gen()->WorkerPool().EmplaceJob<JobCompileUicT>(mapping,
+                                                         std::move(reason));
   }
 }
 
@@ -1871,19 +1899,19 @@ bool cmQtAutoMocUicT::JobProbeDepsUicT::Probe(MappingT const& mapping,
   cmFileTime outputFileTime;
   if (!outputFileTime.Load(outputFile)) {
     if (reason != nullptr) {
-      *reason =
-        cmStrCat("Generating ", MessagePath(outputFile),
-                 ", because it doesn't exist, from ", MessagePath(sourceFile));
+      *reason = cmStrCat("Generating ", this->MessagePath(outputFile),
+                         ", because it doesn't exist, from ",
+                         this->MessagePath(sourceFile));
     }
     return true;
   }
 
   // Test if the uic settings changed
-  if (UicConst().SettingsChanged) {
+  if (this->UicConst().SettingsChanged) {
     if (reason != nullptr) {
-      *reason = cmStrCat("Generating ", MessagePath(outputFile),
+      *reason = cmStrCat("Generating ", this->MessagePath(outputFile),
                          ", because the uic settings changed, from ",
-                         MessagePath(sourceFile));
+                         this->MessagePath(sourceFile));
     }
     return true;
   }
@@ -1891,19 +1919,19 @@ bool cmQtAutoMocUicT::JobProbeDepsUicT::Probe(MappingT const& mapping,
   // Test if the source file is newer
   if (outputFileTime.Older(mapping.SourceFile->FileTime)) {
     if (reason != nullptr) {
-      *reason = cmStrCat("Generating ", MessagePath(outputFile),
+      *reason = cmStrCat("Generating ", this->MessagePath(outputFile),
                          " because it's older than the source file ",
-                         MessagePath(sourceFile));
+                         this->MessagePath(sourceFile));
     }
     return true;
   }
 
   // Test if the uic executable is newer
-  if (outputFileTime.Older(UicConst().ExecutableTime)) {
+  if (outputFileTime.Older(this->UicConst().ExecutableTime)) {
     if (reason != nullptr) {
-      *reason = cmStrCat("Generating ", MessagePath(outputFile),
+      *reason = cmStrCat("Generating ", this->MessagePath(outputFile),
                          ", because it's older than the uic executable, from ",
-                         MessagePath(sourceFile));
+                         this->MessagePath(sourceFile));
     }
     return true;
   }
@@ -1919,64 +1947,64 @@ void cmQtAutoMocUicT::JobProbeDepsFinishT::Process()
     auto createDirs = [this](GenT genType, StringSet const& dirSet) {
       for (std::string const& dirName : dirSet) {
         if (!cmSystemTools::MakeDirectory(dirName)) {
-          this->LogError(
-            genType,
-            cmStrCat("Creating directory ", MessagePath(dirName), " failed."));
+          this->LogError(genType,
+                         cmStrCat("Creating directory ",
+                                  this->MessagePath(dirName), " failed."));
           return;
         }
       }
     };
-    if (MocConst().Enabled && UicConst().Enabled) {
-      StringSet outputDirs = MocEval().OutputDirs;
-      outputDirs.insert(UicEval().OutputDirs.begin(),
-                        UicEval().OutputDirs.end());
+    if (this->MocConst().Enabled && this->UicConst().Enabled) {
+      StringSet outputDirs = this->MocEval().OutputDirs;
+      outputDirs.insert(this->UicEval().OutputDirs.begin(),
+                        this->UicEval().OutputDirs.end());
       createDirs(GenT::GEN, outputDirs);
-    } else if (MocConst().Enabled) {
-      createDirs(GenT::MOC, MocEval().OutputDirs);
-    } else if (UicConst().Enabled) {
-      createDirs(GenT::UIC, UicEval().OutputDirs);
+    } else if (this->MocConst().Enabled) {
+      createDirs(GenT::MOC, this->MocEval().OutputDirs);
+    } else if (this->UicConst().Enabled) {
+      createDirs(GenT::UIC, this->UicEval().OutputDirs);
     }
   }
 
-  if (MocConst().Enabled) {
+  if (this->MocConst().Enabled) {
     // Add mocs compilations job
-    Gen()->WorkerPool().EmplaceJob<JobMocsCompilationT>();
+    this->Gen()->WorkerPool().EmplaceJob<JobMocsCompilationT>();
   }
 
-  if (!BaseConst().DepFile.empty()) {
+  if (!this->BaseConst().DepFile.empty()) {
     // Add job to merge dep files
-    Gen()->WorkerPool().EmplaceJob<JobDepFilesMergeT>();
+    this->Gen()->WorkerPool().EmplaceJob<JobDepFilesMergeT>();
   }
 
   // Add finish job
-  Gen()->WorkerPool().EmplaceJob<JobFinishT>();
+  this->Gen()->WorkerPool().EmplaceJob<JobFinishT>();
 }
 
 void cmQtAutoMocUicT::JobCompileMocT::Process()
 {
-  std::string const& sourceFile = Mapping->SourceFile->FileName;
-  std::string const& outputFile = Mapping->OutputFile;
+  std::string const& sourceFile = this->Mapping->SourceFile->FileName;
+  std::string const& outputFile = this->Mapping->OutputFile;
 
   // Compose moc command
   std::vector<std::string> cmd;
   {
     // Reserve large enough
-    cmd.reserve(MocConst().OptionsDefinitions.size() +
-                MocConst().OptionsIncludes.size() +
-                MocConst().OptionsExtra.size() + 16);
-    cmd.push_back(MocConst().Executable);
+    cmd.reserve(this->MocConst().OptionsDefinitions.size() +
+                this->MocConst().OptionsIncludes.size() +
+                this->MocConst().OptionsExtra.size() + 16);
+    cmd.push_back(this->MocConst().Executable);
     // Add definitions
-    cm::append(cmd, MocConst().OptionsDefinitions);
+    cm::append(cmd, this->MocConst().OptionsDefinitions);
     // Add includes
-    cm::append(cmd, MocConst().OptionsIncludes);
+    cm::append(cmd, this->MocConst().OptionsIncludes);
     // Add predefs include
-    if (!MocConst().PredefsFileAbs.empty()) {
+    if (!this->MocConst().PredefsFileAbs.empty()) {
       cmd.emplace_back("--include");
-      cmd.push_back(MocConst().PredefsFileAbs);
+      cmd.push_back(this->MocConst().PredefsFileAbs);
     }
     // Add path prefix on demand
-    if (MocConst().PathPrefix && Mapping->SourceFile->IsHeader) {
-      for (std::string const& dir : MocConst().IncludePaths) {
+    if (this->MocConst().PathPrefix && this->Mapping->SourceFile->IsHeader) {
+      for (std::string const& dir : this->MocConst().IncludePaths) {
         cm::string_view prefix = sourceFile;
         if (cmHasPrefix(prefix, dir)) {
           prefix.remove_prefix(dir.size());
@@ -1996,8 +2024,8 @@ void cmQtAutoMocUicT::JobCompileMocT::Process()
       }
     }
     // Add extra options
-    cm::append(cmd, MocConst().OptionsExtra);
-    if (MocConst().CanOutputDependencies) {
+    cm::append(cmd, this->MocConst().OptionsExtra);
+    if (this->MocConst().CanOutputDependencies) {
       cmd.emplace_back("--output-dep-file");
     }
     // Add output file
@@ -2009,60 +2037,60 @@ void cmQtAutoMocUicT::JobCompileMocT::Process()
 
   // Execute moc command
   cmWorkerPool::ProcessResultT result;
-  if (!RunProcess(GenT::MOC, result, cmd, Reason.get())) {
+  if (!this->RunProcess(GenT::MOC, result, cmd, this->Reason.get())) {
     // Moc command failed
     std::string includers;
-    if (!Mapping->IncluderFiles.empty()) {
+    if (!this->Mapping->IncluderFiles.empty()) {
       includers = "included by\n";
-      for (auto const& item : Mapping->IncluderFiles) {
-        includers += cmStrCat("  ", MessagePath(item->FileName), '\n');
+      for (auto const& item : this->Mapping->IncluderFiles) {
+        includers += cmStrCat("  ", this->MessagePath(item->FileName), '\n');
       }
     }
-    LogCommandError(GenT::MOC,
-                    cmStrCat("The moc process failed to compile\n  ",
-                             MessagePath(sourceFile), "\ninto\n  ",
-                             MessagePath(outputFile), '\n', includers,
-                             result.ErrorMessage),
-                    cmd, result.StdOut);
+    this->LogCommandError(GenT::MOC,
+                          cmStrCat("The moc process failed to compile\n  ",
+                                   this->MessagePath(sourceFile), "\ninto\n  ",
+                                   this->MessagePath(outputFile), '\n',
+                                   includers, result.ErrorMessage),
+                          cmd, result.StdOut);
     return;
   }
 
   // Moc command success. Print moc output.
   if (!result.StdOut.empty()) {
-    Log().Info(GenT::MOC, result.StdOut);
+    this->Log().Info(GenT::MOC, result.StdOut);
   }
 
   // Extract dependencies from the dep file moc generated for us
-  if (MocConst().CanOutputDependencies) {
+  if (this->MocConst().CanOutputDependencies) {
     const std::string depfile = outputFile + ".d";
-    if (Log().Verbose()) {
-      Log().Info(GenT::MOC,
-                 "Reading dependencies from " + MessagePath(depfile));
+    if (this->Log().Verbose()) {
+      this->Log().Info(
+        GenT::MOC, "Reading dependencies from " + this->MessagePath(depfile));
     }
     if (!cmSystemTools::FileExists(depfile)) {
-      Log().Warning(GenT::MOC,
-                    "Dependency file " + MessagePath(depfile) +
-                      " does not exist.");
+      this->Log().Warning(GenT::MOC,
+                          "Dependency file " + this->MessagePath(depfile) +
+                            " does not exist.");
       return;
     }
-    CacheEntry->Moc.Depends = dependenciesFromDepFile(depfile.c_str());
+    this->CacheEntry->Moc.Depends = dependenciesFromDepFile(depfile.c_str());
   }
 }
 
 void cmQtAutoMocUicT::JobCompileUicT::Process()
 {
-  std::string const& sourceFile = Mapping->SourceFile->FileName;
-  std::string const& outputFile = Mapping->OutputFile;
+  std::string const& sourceFile = this->Mapping->SourceFile->FileName;
+  std::string const& outputFile = this->Mapping->OutputFile;
 
   // Compose uic command
   std::vector<std::string> cmd;
-  cmd.push_back(UicConst().Executable);
+  cmd.push_back(this->UicConst().Executable);
   {
-    std::vector<std::string> allOpts = UicConst().Options;
-    auto optionIt = UicConst().UiFiles.find(sourceFile);
-    if (optionIt != UicConst().UiFiles.end()) {
+    std::vector<std::string> allOpts = this->UicConst().Options;
+    auto optionIt = this->UicConst().UiFiles.find(sourceFile);
+    if (optionIt != this->UicConst().UiFiles.end()) {
       UicMergeOptions(allOpts, optionIt->second.Options,
-                      (BaseConst().QtVersion.Major == 5));
+                      (this->BaseConst().QtVersion.Major == 5));
     }
     cm::append(cmd, allOpts);
   }
@@ -2071,24 +2099,25 @@ void cmQtAutoMocUicT::JobCompileUicT::Process()
   cmd.emplace_back(sourceFile);
 
   cmWorkerPool::ProcessResultT result;
-  if (RunProcess(GenT::UIC, result, cmd, Reason.get())) {
+  if (this->RunProcess(GenT::UIC, result, cmd, this->Reason.get())) {
     // Uic command success
     // Print uic output
     if (!result.StdOut.empty()) {
-      Log().Info(GenT::UIC, result.StdOut);
+      this->Log().Info(GenT::UIC, result.StdOut);
     }
   } else {
     // Uic command failed
     std::string includers;
-    for (auto const& item : Mapping->IncluderFiles) {
-      includers += cmStrCat("  ", MessagePath(item->FileName), '\n');
+    for (auto const& item : this->Mapping->IncluderFiles) {
+      includers += cmStrCat("  ", this->MessagePath(item->FileName), '\n');
     }
-    LogCommandError(GenT::UIC,
-                    cmStrCat("The uic process failed to compile\n  ",
-                             MessagePath(sourceFile), "\ninto\n  ",
-                             MessagePath(outputFile), "\nincluded by\n",
-                             includers, result.ErrorMessage),
-                    cmd, result.StdOut);
+    this->LogCommandError(GenT::UIC,
+                          cmStrCat("The uic process failed to compile\n  ",
+                                   this->MessagePath(sourceFile), "\ninto\n  ",
+                                   this->MessagePath(outputFile),
+                                   "\nincluded by\n", includers,
+                                   result.ErrorMessage),
+                          cmd, result.StdOut);
   }
 }
 
@@ -2098,41 +2127,41 @@ void cmQtAutoMocUicT::JobMocsCompilationT::Process()
   std::string content =
     "// This file is autogenerated. Changes will be overwritten.\n";
 
-  if (MocEval().CompFiles.empty()) {
+  if (this->MocEval().CompFiles.empty()) {
     // Placeholder content
     content += "// No files found that require moc or the moc files are "
                "included\n"
                "enum some_compilers { need_more_than_nothing };\n";
   } else {
     // Valid content
-    const bool mc = BaseConst().MultiConfig;
+    const bool mc = this->BaseConst().MultiConfig;
     cm::string_view const wrapFront = mc ? "#include <" : "#include \"";
     cm::string_view const wrapBack = mc ? ">\n" : "\"\n";
-    content += cmWrap(wrapFront, MocEval().CompFiles, wrapBack, "");
+    content += cmWrap(wrapFront, this->MocEval().CompFiles, wrapBack, "");
   }
 
-  std::string const& compAbs = MocConst().CompFileAbs;
+  std::string const& compAbs = this->MocConst().CompFileAbs;
   if (cmQtAutoGenerator::FileDiffers(compAbs, content)) {
     // Actually write mocs compilation file
-    if (Log().Verbose()) {
-      Log().Info(GenT::MOC,
-                 "Generating MOC compilation " + MessagePath(compAbs));
+    if (this->Log().Verbose()) {
+      this->Log().Info(
+        GenT::MOC, "Generating MOC compilation " + this->MessagePath(compAbs));
     }
     if (!FileWrite(compAbs, content)) {
-      LogError(GenT::MOC,
-               cmStrCat("Writing MOC compilation ", MessagePath(compAbs),
-                        " failed."));
+      this->LogError(GenT::MOC,
+                     cmStrCat("Writing MOC compilation ",
+                              this->MessagePath(compAbs), " failed."));
     }
-  } else if (MocEval().CompUpdated) {
+  } else if (this->MocEval().CompUpdated) {
     // Only touch mocs compilation file
-    if (Log().Verbose()) {
-      Log().Info(GenT::MOC,
-                 "Touching MOC compilation " + MessagePath(compAbs));
+    if (this->Log().Verbose()) {
+      this->Log().Info(
+        GenT::MOC, "Touching MOC compilation " + this->MessagePath(compAbs));
     }
     if (!cmSystemTools::Touch(compAbs, false)) {
-      LogError(GenT::MOC,
-               cmStrCat("Touching MOC compilation ", MessagePath(compAbs),
-                        " failed."));
+      this->LogError(GenT::MOC,
+                     cmStrCat("Touching MOC compilation ",
+                              this->MessagePath(compAbs), " failed."));
     }
   }
 }
@@ -2171,10 +2200,11 @@ std::string escapeDependencyPath(cm::string_view path)
 
 void cmQtAutoMocUicT::JobDepFilesMergeT::Process()
 {
-  if (Log().Verbose()) {
-    Log().Info(GenT::MOC,
-               cmStrCat("Merging MOC dependencies into ",
-                        MessagePath(BaseConst().DepFile.c_str())));
+  if (this->Log().Verbose()) {
+    this->Log().Info(
+      GenT::MOC,
+      cmStrCat("Merging MOC dependencies into ",
+               this->MessagePath(this->BaseConst().DepFile.c_str())));
   }
   auto processDepFile =
     [](const std::string& mocOutputFile) -> std::vector<std::string> {
@@ -2185,8 +2215,8 @@ void cmQtAutoMocUicT::JobDepFilesMergeT::Process()
     return dependenciesFromDepFile(f.c_str());
   };
 
-  std::vector<std::string> dependencies = BaseConst().ListFiles;
-  ParseCacheT& parseCache = BaseEval().ParseCache;
+  std::vector<std::string> dependencies = this->BaseConst().ListFiles;
+  ParseCacheT& parseCache = this->BaseEval().ParseCache;
   auto processMappingEntry = [&](const MappingMapT::value_type& m) {
     auto cacheEntry = parseCache.GetOrInsert(m.first);
     if (cacheEntry.first->Moc.Depends.empty()) {
@@ -2197,10 +2227,10 @@ void cmQtAutoMocUicT::JobDepFilesMergeT::Process()
                         cacheEntry.first->Moc.Depends.end());
   };
 
-  std::for_each(MocEval().HeaderMappings.begin(),
-                MocEval().HeaderMappings.end(), processMappingEntry);
-  std::for_each(MocEval().SourceMappings.begin(),
-                MocEval().SourceMappings.end(), processMappingEntry);
+  std::for_each(this->MocEval().HeaderMappings.begin(),
+                this->MocEval().HeaderMappings.end(), processMappingEntry);
+  std::for_each(this->MocEval().SourceMappings.begin(),
+                this->MocEval().SourceMappings.end(), processMappingEntry);
 
   // Remove duplicates to make the depfile smaller
   std::sort(dependencies.begin(), dependencies.end());
@@ -2208,39 +2238,42 @@ void cmQtAutoMocUicT::JobDepFilesMergeT::Process()
                      dependencies.end());
 
   // Add form files
-  for (const auto& uif : UicEval().UiFiles) {
+  for (const auto& uif : this->UicEval().UiFiles) {
     dependencies.push_back(uif.first);
   }
 
   // Write the file
   cmsys::ofstream ofs;
-  ofs.open(BaseConst().DepFile.c_str(),
+  ofs.open(this->BaseConst().DepFile.c_str(),
            (std::ios::out | std::ios::binary | std::ios::trunc));
   if (!ofs) {
-    LogError(GenT::GEN,
-             cmStrCat("Cannot open ", MessagePath(BaseConst().DepFile),
-                      " for writing."));
+    this->LogError(GenT::GEN,
+                   cmStrCat("Cannot open ",
+                            this->MessagePath(this->BaseConst().DepFile),
+                            " for writing."));
     return;
   }
-  ofs << BaseConst().DepFileRuleName << ": \\\n";
+  ofs << this->BaseConst().DepFileRuleName << ": \\\n";
   for (const std::string& file : dependencies) {
     ofs << '\t' << escapeDependencyPath(file) << " \\\n";
     if (!ofs.good()) {
-      LogError(GenT::GEN,
-               cmStrCat("Writing depfile", MessagePath(BaseConst().DepFile),
-                        " failed."));
+      this->LogError(GenT::GEN,
+                     cmStrCat("Writing depfile",
+                              this->MessagePath(this->BaseConst().DepFile),
+                              " failed."));
       return;
     }
   }
 
   // Add the CMake executable to re-new cache data if necessary.
   // Also, this is the last entry, so don't add a backslash.
-  ofs << '\t' << escapeDependencyPath(BaseConst().CMakeExecutable) << '\n';
+  ofs << '\t' << escapeDependencyPath(this->BaseConst().CMakeExecutable)
+      << '\n';
 }
 
 void cmQtAutoMocUicT::JobFinishT::Process()
 {
-  Gen()->AbortSuccess();
+  this->Gen()->AbortSuccess();
 }
 
 cmQtAutoMocUicT::cmQtAutoMocUicT()
@@ -2252,42 +2285,51 @@ cmQtAutoMocUicT::~cmQtAutoMocUicT() = default;
 bool cmQtAutoMocUicT::InitFromInfo(InfoT const& info)
 {
   // -- Required settings
-  if (!info.GetBool("MULTI_CONFIG", BaseConst_.MultiConfig, true) ||
-      !info.GetUInt("QT_VERSION_MAJOR", BaseConst_.QtVersion.Major, true) ||
-      !info.GetUInt("QT_VERSION_MINOR", BaseConst_.QtVersion.Minor, true) ||
-      !info.GetUInt("PARALLEL", BaseConst_.ThreadCount, false) ||
-      !info.GetString("BUILD_DIR", BaseConst_.AutogenBuildDir, true) ||
-      !info.GetStringConfig("INCLUDE_DIR", BaseConst_.AutogenIncludeDir,
+  if (!info.GetBool("MULTI_CONFIG", this->BaseConst_.MultiConfig, true) ||
+      !info.GetUInt("QT_VERSION_MAJOR", this->BaseConst_.QtVersion.Major,
+                    true) ||
+      !info.GetUInt("QT_VERSION_MINOR", this->BaseConst_.QtVersion.Minor,
+                    true) ||
+      !info.GetUInt("PARALLEL", this->BaseConst_.ThreadCount, false) ||
+      !info.GetString("BUILD_DIR", this->BaseConst_.AutogenBuildDir, true) ||
+      !info.GetStringConfig("INCLUDE_DIR", this->BaseConst_.AutogenIncludeDir,
                             true) ||
-      !info.GetString("CMAKE_EXECUTABLE", BaseConst_.CMakeExecutable, true) ||
-      !info.GetStringConfig("PARSE_CACHE_FILE", BaseConst_.ParseCacheFile,
-                            true) ||
-      !info.GetString("DEP_FILE", BaseConst_.DepFile, false) ||
-      !info.GetString("DEP_FILE_RULE_NAME", BaseConst_.DepFileRuleName,
+      !info.GetString("CMAKE_EXECUTABLE", this->BaseConst_.CMakeExecutable,
+                      true) ||
+      !info.GetStringConfig("PARSE_CACHE_FILE",
+                            this->BaseConst_.ParseCacheFile, true) ||
+      !info.GetString("DEP_FILE", this->BaseConst_.DepFile, false) ||
+      !info.GetString("DEP_FILE_RULE_NAME", this->BaseConst_.DepFileRuleName,
+                      false) ||
+      !info.GetStringConfig("SETTINGS_FILE", this->SettingsFile_, true) ||
+      !info.GetArray("CMAKE_LIST_FILES", this->BaseConst_.ListFiles, true) ||
+      !info.GetArray("HEADER_EXTENSIONS", this->BaseConst_.HeaderExtensions,
+                     true) ||
+      !info.GetString("QT_MOC_EXECUTABLE", this->MocConst_.Executable,
                       false) ||
-      !info.GetStringConfig("SETTINGS_FILE", SettingsFile_, true) ||
-      !info.GetArray("CMAKE_LIST_FILES", BaseConst_.ListFiles, true) ||
-      !info.GetArray("HEADER_EXTENSIONS", BaseConst_.HeaderExtensions, true) ||
-      !info.GetString("QT_MOC_EXECUTABLE", MocConst_.Executable, false) ||
-      !info.GetString("QT_UIC_EXECUTABLE", UicConst_.Executable, false)) {
+      !info.GetString("QT_UIC_EXECUTABLE", this->UicConst_.Executable,
+                      false)) {
     return false;
   }
 
   // -- Checks
-  if (!BaseConst_.CMakeExecutableTime.Load(BaseConst_.CMakeExecutable)) {
-    return info.LogError(cmStrCat("The CMake executable ",
-                                  MessagePath(BaseConst_.CMakeExecutable),
-                                  " does not exist."));
+  if (!this->BaseConst_.CMakeExecutableTime.Load(
+        this->BaseConst_.CMakeExecutable)) {
+    return info.LogError(
+      cmStrCat("The CMake executable ",
+               this->MessagePath(this->BaseConst_.CMakeExecutable),
+               " does not exist."));
   }
 
   // -- Evaluate values
-  BaseConst_.ThreadCount = std::min(BaseConst_.ThreadCount, ParallelMax);
-  WorkerPool_.SetThreadCount(BaseConst_.ThreadCount);
+  this->BaseConst_.ThreadCount =
+    std::min(this->BaseConst_.ThreadCount, ParallelMax);
+  this->WorkerPool_.SetThreadCount(this->BaseConst_.ThreadCount);
 
   // -- Moc
-  if (!MocConst_.Executable.empty()) {
+  if (!this->MocConst_.Executable.empty()) {
     // -- Moc is enabled
-    MocConst_.Enabled = true;
+    this->MocConst_.Enabled = true;
 
     // -- Temporary buffers
     struct
@@ -2297,18 +2339,21 @@ bool cmQtAutoMocUicT::InitFromInfo(InfoT const& info)
     } tmp;
 
     // -- Required settings
-    if (!info.GetBool("MOC_RELAXED_MODE", MocConst_.RelaxedMode, false) ||
-        !info.GetBool("MOC_PATH_PREFIX", MocConst_.PathPrefix, true) ||
-        !info.GetArray("MOC_SKIP", MocConst_.SkipList, false) ||
-        !info.GetArrayConfig("MOC_DEFINITIONS", MocConst_.Definitions,
+    if (!info.GetBool("MOC_RELAXED_MODE", this->MocConst_.RelaxedMode,
+                      false) ||
+        !info.GetBool("MOC_PATH_PREFIX", this->MocConst_.PathPrefix, true) ||
+        !info.GetArray("MOC_SKIP", this->MocConst_.SkipList, false) ||
+        !info.GetArrayConfig("MOC_DEFINITIONS", this->MocConst_.Definitions,
+                             false) ||
+        !info.GetArrayConfig("MOC_INCLUDES", this->MocConst_.IncludePaths,
                              false) ||
-        !info.GetArrayConfig("MOC_INCLUDES", MocConst_.IncludePaths, false) ||
-        !info.GetArray("MOC_OPTIONS", MocConst_.OptionsExtra, false) ||
-        !info.GetStringConfig("MOC_COMPILATION_FILE", MocConst_.CompFileAbs,
-                              true) ||
-        !info.GetArray("MOC_PREDEFS_CMD", MocConst_.PredefsCmd, false) ||
-        !info.GetStringConfig("MOC_PREDEFS_FILE", MocConst_.PredefsFileAbs,
-                              !MocConst_.PredefsCmd.empty()) ||
+        !info.GetArray("MOC_OPTIONS", this->MocConst_.OptionsExtra, false) ||
+        !info.GetStringConfig("MOC_COMPILATION_FILE",
+                              this->MocConst_.CompFileAbs, true) ||
+        !info.GetArray("MOC_PREDEFS_CMD", this->MocConst_.PredefsCmd, false) ||
+        !info.GetStringConfig("MOC_PREDEFS_FILE",
+                              this->MocConst_.PredefsFileAbs,
+                              !this->MocConst_.PredefsCmd.empty()) ||
         !info.GetArray("MOC_MACRO_NAMES", tmp.MacroNames, true) ||
         !info.GetArray("MOC_DEPEND_FILTERS", tmp.DependFilters, false)) {
       return false;
@@ -2316,12 +2361,12 @@ bool cmQtAutoMocUicT::InitFromInfo(InfoT const& info)
 
     // -- Evaluate settings
     for (std::string const& item : tmp.MacroNames) {
-      MocConst_.MacroFilters.emplace_back(
+      this->MocConst_.MacroFilters.emplace_back(
         item, ("[\n][ \t]*{?[ \t]*" + item).append("[^a-zA-Z0-9_]"));
     }
     // Can moc output dependencies or do we need to setup dependency filters?
-    if (BaseConst_.QtVersion >= IntegerVersion(5, 15)) {
-      MocConst_.CanOutputDependencies = true;
+    if (this->BaseConst_.QtVersion >= IntegerVersion(5, 15)) {
+      this->MocConst_.CanOutputDependencies = true;
     } else {
       Json::Value const& val = info.GetValue("MOC_DEPEND_FILTERS");
       if (!val.isArray()) {
@@ -2371,22 +2416,23 @@ bool cmQtAutoMocUicT::InitFromInfo(InfoT const& info)
       }
     }
     // Check if moc executable exists (by reading the file time)
-    if (!MocConst_.ExecutableTime.Load(MocConst_.Executable)) {
-      return info.LogError(cmStrCat("The moc executable ",
-                                    MessagePath(MocConst_.Executable),
-                                    " does not exist."));
+    if (!this->MocConst_.ExecutableTime.Load(this->MocConst_.Executable)) {
+      return info.LogError(cmStrCat(
+        "The moc executable ", this->MessagePath(this->MocConst_.Executable),
+        " does not exist."));
     }
   }
 
   // -- Uic
-  if (!UicConst_.Executable.empty()) {
+  if (!this->UicConst_.Executable.empty()) {
     // Uic is enabled
-    UicConst_.Enabled = true;
+    this->UicConst_.Enabled = true;
 
     // -- Required settings
-    if (!info.GetArray("UIC_SKIP", UicConst_.SkipList, false) ||
-        !info.GetArray("UIC_SEARCH_PATHS", UicConst_.SearchPaths, false) ||
-        !info.GetArrayConfig("UIC_OPTIONS", UicConst_.Options, false)) {
+    if (!info.GetArray("UIC_SKIP", this->UicConst_.SkipList, false) ||
+        !info.GetArray("UIC_SEARCH_PATHS", this->UicConst_.SearchPaths,
+                       false) ||
+        !info.GetArrayConfig("UIC_OPTIONS", this->UicConst_.Options, false)) {
       return false;
     }
     // .ui files
@@ -2420,17 +2466,17 @@ bool cmQtAutoMocUicT::InitFromInfo(InfoT const& info)
           return false;
         }
 
-        auto& uiFile = UicConst_.UiFiles[entryName.asString()];
+        auto& uiFile = this->UicConst_.UiFiles[entryName.asString()];
         InfoT::GetJsonArray(uiFile.Options, entryOptions);
       }
     }
 
     // -- Evaluate settings
     // Check if uic executable exists (by reading the file time)
-    if (!UicConst_.ExecutableTime.Load(UicConst_.Executable)) {
-      return info.LogError(cmStrCat("The uic executable ",
-                                    MessagePath(UicConst_.Executable),
-                                    " does not exist."));
+    if (!this->UicConst_.ExecutableTime.Load(this->UicConst_.Executable)) {
+      return info.LogError(cmStrCat(
+        "The uic executable ", this->MessagePath(this->UicConst_.Executable),
+        " does not exist."));
     }
   }
 
@@ -2505,14 +2551,15 @@ bool cmQtAutoMocUicT::InitFromInfo(InfoT const& info)
       sourceHandle->IsHeader = true;
       sourceHandle->Moc = (flags[0] == 'M');
       sourceHandle->Uic = (flags[1] == 'U');
-      if (sourceHandle->Moc && MocConst().Enabled) {
+      if (sourceHandle->Moc && this->MocConst().Enabled) {
         if (build.empty()) {
           return info.LogError(
             cmStrCat("Header file ", ii, " build path is empty"));
         }
         sourceHandle->BuildPath = std::move(build);
       }
-      BaseEval().Headers.emplace(std::move(name), std::move(sourceHandle));
+      this->BaseEval().Headers.emplace(std::move(name),
+                                       std::move(sourceHandle));
     }
   }
 
@@ -2583,18 +2630,19 @@ bool cmQtAutoMocUicT::InitFromInfo(InfoT const& info)
       sourceHandle->IsHeader = false;
       sourceHandle->Moc = (flags[0] == 'M');
       sourceHandle->Uic = (flags[1] == 'U');
-      BaseEval().Sources.emplace(std::move(name), std::move(sourceHandle));
+      this->BaseEval().Sources.emplace(std::move(name),
+                                       std::move(sourceHandle));
     }
   }
 
   // -- Init derived information
   // Moc variables
-  if (MocConst().Enabled) {
+  if (this->MocConst().Enabled) {
     // Compose moc includes list
     {
       // Compute framework paths
       std::set<std::string> frameworkPaths;
-      for (std::string const& path : MocConst().IncludePaths) {
+      for (std::string const& path : this->MocConst().IncludePaths) {
         // Extract framework path
         if (cmHasLiteralSuffix(path, ".framework/Headers")) {
           // Go up twice to get to the framework root
@@ -2605,24 +2653,25 @@ bool cmQtAutoMocUicT::InitFromInfo(InfoT const& info)
         }
       }
       // Reserve options
-      MocConst_.OptionsIncludes.reserve(MocConst().IncludePaths.size() +
-                                        frameworkPaths.size() * 2);
+      this->MocConst_.OptionsIncludes.reserve(
+        this->MocConst().IncludePaths.size() + frameworkPaths.size() * 2);
       // Append includes
-      for (std::string const& path : MocConst().IncludePaths) {
-        MocConst_.OptionsIncludes.emplace_back("-I" + path);
+      for (std::string const& path : this->MocConst().IncludePaths) {
+        this->MocConst_.OptionsIncludes.emplace_back("-I" + path);
       }
       // Append framework includes
       for (std::string const& path : frameworkPaths) {
-        MocConst_.OptionsIncludes.emplace_back("-F");
-        MocConst_.OptionsIncludes.push_back(path);
+        this->MocConst_.OptionsIncludes.emplace_back("-F");
+        this->MocConst_.OptionsIncludes.push_back(path);
       }
     }
 
     // Compose moc definitions list
     {
-      MocConst_.OptionsDefinitions.reserve(MocConst().Definitions.size());
-      for (std::string const& def : MocConst().Definitions) {
-        MocConst_.OptionsDefinitions.emplace_back("-D" + def);
+      this->MocConst_.OptionsDefinitions.reserve(
+        this->MocConst().Definitions.size());
+      for (std::string const& def : this->MocConst().Definitions) {
+        this->MocConst_.OptionsDefinitions.emplace_back("-D" + def);
       }
     }
   }
@@ -2633,16 +2682,16 @@ bool cmQtAutoMocUicT::InitFromInfo(InfoT const& info)
 template <class JOBTYPE>
 void cmQtAutoMocUicT::CreateParseJobs(SourceFileMapT const& sourceMap)
 {
-  cmFileTime const parseCacheTime = BaseEval().ParseCacheTime;
-  ParseCacheT& parseCache = BaseEval().ParseCache;
+  cmFileTime const parseCacheTime = this->BaseEval().ParseCacheTime;
+  ParseCacheT& parseCache = this->BaseEval().ParseCache;
   for (auto& src : sourceMap) {
     // Get or create the file parse data reference
     ParseCacheT::GetOrInsertT cacheEntry = parseCache.GetOrInsert(src.first);
     src.second->ParseData = std::move(cacheEntry.first);
     // Create a parse job if the cache file was missing or is older
     if (cacheEntry.second || src.second->FileTime.Newer(parseCacheTime)) {
-      BaseEval().ParseCacheChanged = true;
-      WorkerPool().EmplaceJob<JOBTYPE>(src.second);
+      this->BaseEval().ParseCacheChanged = true;
+      this->WorkerPool().EmplaceJob<JOBTYPE>(src.second);
     }
   }
 }
@@ -2650,55 +2699,56 @@ void cmQtAutoMocUicT::CreateParseJobs(SourceFileMapT const& sourceMap)
 /** Concurrently callable implementation of cmSystemTools::CollapseFullPath */
 std::string cmQtAutoMocUicT::CollapseFullPathTS(std::string const& path) const
 {
-  std::lock_guard<std::mutex> guard(CMakeLibMutex_);
-  return cmSystemTools::CollapseFullPath(path, ProjectDirs().CurrentSource);
+  std::lock_guard<std::mutex> guard(this->CMakeLibMutex_);
+  return cmSystemTools::CollapseFullPath(path,
+                                         this->ProjectDirs().CurrentSource);
 }
 
 void cmQtAutoMocUicT::InitJobs()
 {
   // Add moc_predefs.h job
-  if (MocConst().Enabled && !MocConst().PredefsCmd.empty()) {
-    WorkerPool().EmplaceJob<JobMocPredefsT>();
+  if (this->MocConst().Enabled && !this->MocConst().PredefsCmd.empty()) {
+    this->WorkerPool().EmplaceJob<JobMocPredefsT>();
   }
 
   // Add header parse jobs
-  CreateParseJobs<JobParseHeaderT>(BaseEval().Headers);
+  this->CreateParseJobs<JobParseHeaderT>(this->BaseEval().Headers);
   // Add source parse jobs
-  CreateParseJobs<JobParseSourceT>(BaseEval().Sources);
+  this->CreateParseJobs<JobParseSourceT>(this->BaseEval().Sources);
 
   // Add parse cache evaluations jobs
   {
     // Add a fence job to ensure all parsing has finished
-    WorkerPool().EmplaceJob<JobFenceT>();
-    if (MocConst().Enabled) {
-      WorkerPool().EmplaceJob<JobEvalCacheMocT>();
+    this->WorkerPool().EmplaceJob<JobFenceT>();
+    if (this->MocConst().Enabled) {
+      this->WorkerPool().EmplaceJob<JobEvalCacheMocT>();
     }
-    if (UicConst().Enabled) {
-      WorkerPool().EmplaceJob<JobEvalCacheUicT>();
+    if (this->UicConst().Enabled) {
+      this->WorkerPool().EmplaceJob<JobEvalCacheUicT>();
     }
     // Add evaluate job
-    WorkerPool().EmplaceJob<JobEvalCacheFinishT>();
+    this->WorkerPool().EmplaceJob<JobEvalCacheFinishT>();
   }
 }
 
 bool cmQtAutoMocUicT::Process()
 {
-  SettingsFileRead();
-  ParseCacheRead();
-  if (!CreateDirectories()) {
+  this->SettingsFileRead();
+  this->ParseCacheRead();
+  if (!this->CreateDirectories()) {
     return false;
   }
-  InitJobs();
-  if (!WorkerPool_.Process(this)) {
+  this->InitJobs();
+  if (!this->WorkerPool_.Process(this)) {
     return false;
   }
-  if (JobError_) {
+  if (this->JobError_) {
     return false;
   }
-  if (!ParseCacheWrite()) {
+  if (!this->ParseCacheWrite()) {
     return false;
   }
-  if (!SettingsFileWrite()) {
+  if (!this->SettingsFileWrite()) {
     return false;
   }
   return true;
@@ -2714,70 +2764,72 @@ void cmQtAutoMocUicT::SettingsFileRead()
       cryptoHash.Append(";");
     };
 
-    if (MocConst_.Enabled) {
+    if (this->MocConst_.Enabled) {
       cryptoHash.Initialize();
-      cha(MocConst().Executable);
-      for (auto const& item : MocConst().OptionsDefinitions) {
+      cha(this->MocConst().Executable);
+      for (auto const& item : this->MocConst().OptionsDefinitions) {
         cha(item);
       }
-      for (auto const& item : MocConst().OptionsIncludes) {
+      for (auto const& item : this->MocConst().OptionsIncludes) {
         cha(item);
       }
-      for (auto const& item : MocConst().OptionsExtra) {
+      for (auto const& item : this->MocConst().OptionsExtra) {
         cha(item);
       }
-      for (auto const& item : MocConst().PredefsCmd) {
+      for (auto const& item : this->MocConst().PredefsCmd) {
         cha(item);
       }
-      for (auto const& filter : MocConst().DependFilters) {
+      for (auto const& filter : this->MocConst().DependFilters) {
         cha(filter.Key);
       }
-      for (auto const& filter : MocConst().MacroFilters) {
+      for (auto const& filter : this->MocConst().MacroFilters) {
         cha(filter.Key);
       }
-      SettingsStringMoc_ = cryptoHash.FinalizeHex();
+      this->SettingsStringMoc_ = cryptoHash.FinalizeHex();
     }
 
-    if (UicConst().Enabled) {
+    if (this->UicConst().Enabled) {
       cryptoHash.Initialize();
-      cha(UicConst().Executable);
-      std::for_each(UicConst().Options.begin(), UicConst().Options.end(), cha);
-      for (const auto& item : UicConst().UiFiles) {
+      cha(this->UicConst().Executable);
+      std::for_each(this->UicConst().Options.begin(),
+                    this->UicConst().Options.end(), cha);
+      for (const auto& item : this->UicConst().UiFiles) {
         cha(item.first);
         auto const& opts = item.second.Options;
         std::for_each(opts.begin(), opts.end(), cha);
       }
-      SettingsStringUic_ = cryptoHash.FinalizeHex();
+      this->SettingsStringUic_ = cryptoHash.FinalizeHex();
     }
   }
 
   // Read old settings and compare
   {
     std::string content;
-    if (cmQtAutoGenerator::FileRead(content, SettingsFile_)) {
-      if (MocConst().Enabled) {
-        if (SettingsStringMoc_ != SettingsFind(content, "moc")) {
-          MocConst_.SettingsChanged = true;
+    if (cmQtAutoGenerator::FileRead(content, this->SettingsFile_)) {
+      if (this->MocConst().Enabled) {
+        if (this->SettingsStringMoc_ != SettingsFind(content, "moc")) {
+          this->MocConst_.SettingsChanged = true;
         }
       }
-      if (UicConst().Enabled) {
-        if (SettingsStringUic_ != SettingsFind(content, "uic")) {
-          UicConst_.SettingsChanged = true;
+      if (this->UicConst().Enabled) {
+        if (this->SettingsStringUic_ != SettingsFind(content, "uic")) {
+          this->UicConst_.SettingsChanged = true;
         }
       }
       // In case any setting changed remove 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 (MocConst().SettingsChanged || UicConst().SettingsChanged) {
-        cmSystemTools::RemoveFile(SettingsFile_);
+      if (this->MocConst().SettingsChanged ||
+          this->UicConst().SettingsChanged) {
+        cmSystemTools::RemoveFile(this->SettingsFile_);
       }
     } else {
       // Settings file read failed
-      if (MocConst().Enabled) {
-        MocConst_.SettingsChanged = true;
+      if (this->MocConst().Enabled) {
+        this->MocConst_.SettingsChanged = true;
       }
-      if (UicConst().Enabled) {
-        UicConst_.SettingsChanged = true;
+      if (this->UicConst().Enabled) {
+        this->UicConst_.SettingsChanged = true;
       }
     }
   }
@@ -2786,11 +2838,11 @@ void cmQtAutoMocUicT::SettingsFileRead()
 bool cmQtAutoMocUicT::SettingsFileWrite()
 {
   // Only write if any setting changed
-  if (MocConst().SettingsChanged || UicConst().SettingsChanged) {
-    if (Log().Verbose()) {
-      Log().Info(
-        GenT::GEN,
-        cmStrCat("Writing the settings file ", MessagePath(SettingsFile_)));
+  if (this->MocConst().SettingsChanged || this->UicConst().SettingsChanged) {
+    if (this->Log().Verbose()) {
+      this->Log().Info(GenT::GEN,
+                       cmStrCat("Writing the settings file ",
+                                this->MessagePath(this->SettingsFile_)));
     }
     // Compose settings file content
     std::string content;
@@ -2801,17 +2853,18 @@ bool cmQtAutoMocUicT::SettingsFileWrite()
           content += cmStrCat(key, ':', value, '\n');
         }
       };
-      SettingAppend("moc", SettingsStringMoc_);
-      SettingAppend("uic", SettingsStringUic_);
+      SettingAppend("moc", this->SettingsStringMoc_);
+      SettingAppend("uic", this->SettingsStringUic_);
     }
     // Write settings file
     std::string error;
-    if (!cmQtAutoGenerator::FileWrite(SettingsFile_, content, &error)) {
-      Log().Error(GenT::GEN,
-                  cmStrCat("Writing the settings file ",
-                           MessagePath(SettingsFile_), " failed.\n", error));
+    if (!cmQtAutoGenerator::FileWrite(this->SettingsFile_, content, &error)) {
+      this->Log().Error(GenT::GEN,
+                        cmStrCat("Writing the settings file ",
+                                 this->MessagePath(this->SettingsFile_),
+                                 " failed.\n", error));
       // Remove old settings file to trigger a full rebuild on the next run
-      cmSystemTools::RemoveFile(SettingsFile_);
+      cmSystemTools::RemoveFile(this->SettingsFile_);
       return false;
     }
   }
@@ -2822,41 +2875,46 @@ void cmQtAutoMocUicT::ParseCacheRead()
 {
   cm::string_view reason;
   // Don't read the cache if it is invalid
-  if (!BaseEval().ParseCacheTime.Load(BaseConst().ParseCacheFile)) {
+  if (!this->BaseEval().ParseCacheTime.Load(
+        this->BaseConst().ParseCacheFile)) {
     reason = "Refreshing parse cache because it doesn't exist.";
-  } else if (MocConst().SettingsChanged || UicConst().SettingsChanged) {
+  } else if (this->MocConst().SettingsChanged ||
+             this->UicConst().SettingsChanged) {
     reason = "Refreshing parse cache because the settings changed.";
-  } else if (BaseEval().ParseCacheTime.Older(
-               BaseConst().CMakeExecutableTime)) {
+  } else if (this->BaseEval().ParseCacheTime.Older(
+               this->BaseConst().CMakeExecutableTime)) {
     reason =
       "Refreshing parse cache because it is older than the CMake executable.";
   }
 
   if (!reason.empty()) {
     // Don't read but refresh the complete parse cache
-    if (Log().Verbose()) {
-      Log().Info(GenT::GEN, reason);
+    if (this->Log().Verbose()) {
+      this->Log().Info(GenT::GEN, reason);
     }
-    BaseEval().ParseCacheChanged = true;
+    this->BaseEval().ParseCacheChanged = true;
   } else {
     // Read parse cache
-    BaseEval().ParseCache.ReadFromFile(BaseConst().ParseCacheFile);
+    this->BaseEval().ParseCache.ReadFromFile(this->BaseConst().ParseCacheFile);
   }
 }
 
 bool cmQtAutoMocUicT::ParseCacheWrite()
 {
-  if (BaseEval().ParseCacheChanged) {
-    if (Log().Verbose()) {
-      Log().Info(GenT::GEN,
-                 cmStrCat("Writing the parse cache file ",
-                          MessagePath(BaseConst().ParseCacheFile)));
-    }
-    if (!BaseEval().ParseCache.WriteToFile(BaseConst().ParseCacheFile)) {
-      Log().Error(GenT::GEN,
-                  cmStrCat("Writing the parse cache file ",
-                           MessagePath(BaseConst().ParseCacheFile),
-                           " failed."));
+  if (this->BaseEval().ParseCacheChanged) {
+    if (this->Log().Verbose()) {
+      this->Log().Info(
+        GenT::GEN,
+        cmStrCat("Writing the parse cache file ",
+                 this->MessagePath(this->BaseConst().ParseCacheFile)));
+    }
+    if (!this->BaseEval().ParseCache.WriteToFile(
+          this->BaseConst().ParseCacheFile)) {
+      this->Log().Error(
+        GenT::GEN,
+        cmStrCat("Writing the parse cache file ",
+                 this->MessagePath(this->BaseConst().ParseCacheFile),
+                 " failed."));
       return false;
     }
   }
@@ -2866,11 +2924,12 @@ bool cmQtAutoMocUicT::ParseCacheWrite()
 bool cmQtAutoMocUicT::CreateDirectories()
 {
   // Create AUTOGEN include directory
-  if (!cmSystemTools::MakeDirectory(BaseConst().AutogenIncludeDir)) {
-    Log().Error(GenT::GEN,
-                cmStrCat("Creating the AUTOGEN include directory ",
-                         MessagePath(BaseConst().AutogenIncludeDir),
-                         " failed."));
+  if (!cmSystemTools::MakeDirectory(this->BaseConst().AutogenIncludeDir)) {
+    this->Log().Error(
+      GenT::GEN,
+      cmStrCat("Creating the AUTOGEN include directory ",
+               this->MessagePath(this->BaseConst().AutogenIncludeDir),
+               " failed."));
     return false;
   }
   return true;
@@ -2892,21 +2951,21 @@ std::vector<std::string> cmQtAutoMocUicT::dependenciesFromDepFile(
 void cmQtAutoMocUicT::Abort(bool error)
 {
   if (error) {
-    JobError_.store(true);
+    this->JobError_.store(true);
   }
-  WorkerPool_.Abort();
+  this->WorkerPool_.Abort();
 }
 
 std::string cmQtAutoMocUicT::AbsoluteBuildPath(
   cm::string_view relativePath) const
 {
-  return cmStrCat(BaseConst().AutogenBuildDir, '/', relativePath);
+  return cmStrCat(this->BaseConst().AutogenBuildDir, '/', relativePath);
 }
 
 std::string cmQtAutoMocUicT::AbsoluteIncludePath(
   cm::string_view relativePath) const
 {
-  return cmStrCat(BaseConst().AutogenIncludeDir, '/', relativePath);
+  return cmStrCat(this->BaseConst().AutogenIncludeDir, '/', relativePath);
 }
 
 } // End of unnamed namespace
diff --git a/Source/cmQtAutoRcc.cxx b/Source/cmQtAutoRcc.cxx
index 08eb4b5e28..943cc93a91 100644
--- a/Source/cmQtAutoRcc.cxx
+++ b/Source/cmQtAutoRcc.cxx
@@ -35,7 +35,7 @@ public:
 
 private:
   // -- Utility
-  bool IsMultiConfig() const { return MultiConfig_; }
+  bool IsMultiConfig() const { return this->MultiConfig_; }
   std::string MultiConfigOutput() const;
 
   // -- Abstract processing interface
@@ -93,38 +93,41 @@ cmQtAutoRccT::~cmQtAutoRccT() = default;
 bool cmQtAutoRccT::InitFromInfo(InfoT const& info)
 {
   // -- Required settings
-  if (!info.GetBool("MULTI_CONFIG", MultiConfig_, true) ||
-      !info.GetString("BUILD_DIR", AutogenBuildDir_, true) ||
-      !info.GetStringConfig("INCLUDE_DIR", IncludeDir_, true) ||
-      !info.GetString("RCC_EXECUTABLE", RccExecutable_, true) ||
-      !info.GetArray("RCC_LIST_OPTIONS", RccListOptions_, false) ||
-      !info.GetString("LOCK_FILE", LockFile_, true) ||
-      !info.GetStringConfig("SETTINGS_FILE", SettingsFile_, true) ||
-      !info.GetString("SOURCE", QrcFile_, true) ||
-      !info.GetString("OUTPUT_CHECKSUM", RccPathChecksum_, true) ||
-      !info.GetString("OUTPUT_NAME", RccFileName_, true) ||
-      !info.GetArray("OPTIONS", Options_, false) ||
-      !info.GetArray("INPUTS", Inputs_, false)) {
+  if (!info.GetBool("MULTI_CONFIG", this->MultiConfig_, true) ||
+      !info.GetString("BUILD_DIR", this->AutogenBuildDir_, true) ||
+      !info.GetStringConfig("INCLUDE_DIR", this->IncludeDir_, true) ||
+      !info.GetString("RCC_EXECUTABLE", this->RccExecutable_, true) ||
+      !info.GetArray("RCC_LIST_OPTIONS", this->RccListOptions_, false) ||
+      !info.GetString("LOCK_FILE", this->LockFile_, true) ||
+      !info.GetStringConfig("SETTINGS_FILE", this->SettingsFile_, true) ||
+      !info.GetString("SOURCE", this->QrcFile_, true) ||
+      !info.GetString("OUTPUT_CHECKSUM", this->RccPathChecksum_, true) ||
+      !info.GetString("OUTPUT_NAME", this->RccFileName_, true) ||
+      !info.GetArray("OPTIONS", this->Options_, false) ||
+      !info.GetArray("INPUTS", this->Inputs_, false)) {
     return false;
   }
 
   // -- Derive information
-  QrcFileName_ = cmSystemTools::GetFilenameName(QrcFile_);
-  QrcFileDir_ = cmSystemTools::GetFilenamePath(QrcFile_);
-  RccFilePublic_ =
-    cmStrCat(AutogenBuildDir_, '/', RccPathChecksum_, '/', RccFileName_);
+  this->QrcFileName_ = cmSystemTools::GetFilenameName(this->QrcFile_);
+  this->QrcFileDir_ = cmSystemTools::GetFilenamePath(this->QrcFile_);
+  this->RccFilePublic_ =
+    cmStrCat(this->AutogenBuildDir_, '/', this->RccPathChecksum_, '/',
+             this->RccFileName_);
 
   // rcc output file name
-  if (IsMultiConfig()) {
-    RccFileOutput_ = cmStrCat(IncludeDir_, '/', MultiConfigOutput());
+  if (this->IsMultiConfig()) {
+    this->RccFileOutput_ =
+      cmStrCat(this->IncludeDir_, '/', this->MultiConfigOutput());
   } else {
-    RccFileOutput_ = RccFilePublic_;
+    this->RccFileOutput_ = this->RccFilePublic_;
   }
 
   // -- Checks
-  if (!RccExecutableTime_.Load(RccExecutable_)) {
-    return info.LogError(cmStrCat(
-      "The rcc executable ", MessagePath(RccExecutable_), " does not exist."));
+  if (!this->RccExecutableTime_.Load(this->RccExecutable_)) {
+    return info.LogError(cmStrCat("The rcc executable ",
+                                  this->MessagePath(this->RccExecutable_),
+                                  " does not exist."));
   }
 
   return true;
@@ -132,41 +135,41 @@ bool cmQtAutoRccT::InitFromInfo(InfoT const& info)
 
 bool cmQtAutoRccT::Process()
 {
-  if (!SettingsFileRead()) {
+  if (!this->SettingsFileRead()) {
     return false;
   }
 
   // Test if the rcc output needs to be regenerated
   bool generate = false;
-  if (!TestQrcRccFiles(generate)) {
+  if (!this->TestQrcRccFiles(generate)) {
     return false;
   }
-  if (!generate && !TestResources(generate)) {
+  if (!generate && !this->TestResources(generate)) {
     return false;
   }
   // Generate on demand
   if (generate) {
-    if (!GenerateRcc()) {
+    if (!this->GenerateRcc()) {
       return false;
     }
   } else {
     // Test if the info file is newer than the output file
-    if (!TestInfoFile()) {
+    if (!this->TestInfoFile()) {
       return false;
     }
   }
 
-  if (!GenerateWrapper()) {
+  if (!this->GenerateWrapper()) {
     return false;
   }
 
-  return SettingsFileWrite();
+  return this->SettingsFileWrite();
 }
 
 std::string cmQtAutoRccT::MultiConfigOutput() const
 {
-  return cmStrCat(RccPathChecksum_, '/',
-                  AppendFilenameSuffix(RccFileName_, "_CMAKE_"));
+  return cmStrCat(this->RccPathChecksum_, '/',
+                  AppendFilenameSuffix(this->RccFileName_, "_CMAKE_"));
 }
 
 bool cmQtAutoRccT::SettingsFileRead()
@@ -178,23 +181,25 @@ bool cmQtAutoRccT::SettingsFileRead()
       cryptoHash.Append(value);
       cryptoHash.Append(";");
     };
-    cha(RccExecutable_);
-    std::for_each(RccListOptions_.begin(), RccListOptions_.end(), cha);
-    cha(QrcFile_);
-    cha(RccPathChecksum_);
-    cha(RccFileName_);
-    std::for_each(Options_.begin(), Options_.end(), cha);
-    std::for_each(Inputs_.begin(), Inputs_.end(), cha);
-    SettingsString_ = cryptoHash.FinalizeHex();
+    cha(this->RccExecutable_);
+    std::for_each(this->RccListOptions_.begin(), this->RccListOptions_.end(),
+                  cha);
+    cha(this->QrcFile_);
+    cha(this->RccPathChecksum_);
+    cha(this->RccFileName_);
+    std::for_each(this->Options_.begin(), this->Options_.end(), cha);
+    std::for_each(this->Inputs_.begin(), this->Inputs_.end(), cha);
+    this->SettingsString_ = cryptoHash.FinalizeHex();
   }
 
   // Make sure the settings file exists
-  if (!cmSystemTools::FileExists(SettingsFile_, true)) {
+  if (!cmSystemTools::FileExists(this->SettingsFile_, true)) {
     // Touch the settings file to make sure it exists
-    if (!cmSystemTools::Touch(SettingsFile_, true)) {
-      Log().Error(GenT::RCC,
-                  cmStrCat("Touching the settings file ",
-                           MessagePath(SettingsFile_), " failed."));
+    if (!cmSystemTools::Touch(this->SettingsFile_, true)) {
+      this->Log().Error(GenT::RCC,
+                        cmStrCat("Touching the settings file ",
+                                 this->MessagePath(this->SettingsFile_),
+                                 " failed."));
       return false;
     }
   }
@@ -202,21 +207,23 @@ bool cmQtAutoRccT::SettingsFileRead()
   // Lock the lock file
   {
     // Make sure the lock file exists
-    if (!cmSystemTools::FileExists(LockFile_, true)) {
-      if (!cmSystemTools::Touch(LockFile_, true)) {
-        Log().Error(GenT::RCC,
-                    cmStrCat("Touching the lock file ", MessagePath(LockFile_),
-                             " failed."));
+    if (!cmSystemTools::FileExists(this->LockFile_, true)) {
+      if (!cmSystemTools::Touch(this->LockFile_, true)) {
+        this->Log().Error(GenT::RCC,
+                          cmStrCat("Touching the lock file ",
+                                   this->MessagePath(this->LockFile_),
+                                   " failed."));
         return false;
       }
     }
     // Lock the lock file
-    cmFileLockResult lockResult =
-      LockFileLock_.Lock(LockFile_, static_cast<unsigned long>(-1));
+    cmFileLockResult lockResult = this->LockFileLock_.Lock(
+      this->LockFile_, static_cast<unsigned long>(-1));
     if (!lockResult.IsOk()) {
-      Log().Error(GenT::RCC,
-                  cmStrCat("Locking of the lock file ", MessagePath(LockFile_),
-                           " failed.\n", lockResult.GetOutputMessage()));
+      this->Log().Error(GenT::RCC,
+                        cmStrCat("Locking of the lock file ",
+                                 this->MessagePath(this->LockFile_),
+                                 " failed.\n", lockResult.GetOutputMessage()));
       return false;
     }
   }
@@ -224,23 +231,24 @@ bool cmQtAutoRccT::SettingsFileRead()
   // Read old settings
   {
     std::string content;
-    if (FileRead(content, SettingsFile_)) {
-      SettingsChanged_ = (SettingsString_ != SettingsFind(content, "rcc"));
+    if (FileRead(content, this->SettingsFile_)) {
+      this->SettingsChanged_ =
+        (this->SettingsString_ != SettingsFind(content, "rcc"));
       // 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_) {
+      if (this->SettingsChanged_) {
         std::string error;
-        if (!FileWrite(SettingsFile_, "", &error)) {
-          Log().Error(GenT::RCC,
-                      cmStrCat("Clearing of the settings file ",
-                               MessagePath(SettingsFile_), " failed.\n",
-                               error));
+        if (!FileWrite(this->SettingsFile_, "", &error)) {
+          this->Log().Error(GenT::RCC,
+                            cmStrCat("Clearing of the settings file ",
+                                     this->MessagePath(this->SettingsFile_),
+                                     " failed.\n", error));
           return false;
         }
       }
     } else {
-      SettingsChanged_ = true;
+      this->SettingsChanged_ = true;
     }
   }
 
@@ -250,26 +258,28 @@ bool cmQtAutoRccT::SettingsFileRead()
 bool cmQtAutoRccT::SettingsFileWrite()
 {
   // Only write if any setting changed
-  if (SettingsChanged_) {
-    if (Log().Verbose()) {
-      Log().Info(GenT::RCC,
-                 "Writing settings file " + MessagePath(SettingsFile_));
+  if (this->SettingsChanged_) {
+    if (this->Log().Verbose()) {
+      this->Log().Info(GenT::RCC,
+                       "Writing settings file " +
+                         this->MessagePath(this->SettingsFile_));
     }
     // Write settings file
-    std::string content = cmStrCat("rcc:", SettingsString_, '\n');
+    std::string content = cmStrCat("rcc:", this->SettingsString_, '\n');
     std::string error;
-    if (!FileWrite(SettingsFile_, content, &error)) {
-      Log().Error(GenT::RCC,
-                  cmStrCat("Writing of the settings file ",
-                           MessagePath(SettingsFile_), " failed.\n", error));
+    if (!FileWrite(this->SettingsFile_, content, &error)) {
+      this->Log().Error(GenT::RCC,
+                        cmStrCat("Writing of the settings file ",
+                                 this->MessagePath(this->SettingsFile_),
+                                 " failed.\n", error));
       // Remove old settings file to trigger a full rebuild on the next run
-      cmSystemTools::RemoveFile(SettingsFile_);
+      cmSystemTools::RemoveFile(this->SettingsFile_);
       return false;
     }
   }
 
   // Unlock the lock file
-  LockFileLock_.Release();
+  this->LockFileLock_.Release();
   return true;
 }
 
@@ -277,52 +287,57 @@ bool cmQtAutoRccT::SettingsFileWrite()
 bool cmQtAutoRccT::TestQrcRccFiles(bool& generate)
 {
   // Test if the rcc input file exists
-  if (!QrcFileTime_.Load(QrcFile_)) {
-    Log().Error(GenT::RCC,
-                cmStrCat("The resources file ", MessagePath(QrcFile_),
-                         " does not exist"));
+  if (!this->QrcFileTime_.Load(this->QrcFile_)) {
+    this->Log().Error(GenT::RCC,
+                      cmStrCat("The resources file ",
+                               this->MessagePath(this->QrcFile_),
+                               " does not exist"));
     return false;
   }
 
   // Test if the rcc output file exists
-  if (!RccFileTime_.Load(RccFileOutput_)) {
-    if (Log().Verbose()) {
-      Reason =
-        cmStrCat("Generating ", MessagePath(RccFileOutput_),
-                 ", because it doesn't exist, from ", MessagePath(QrcFile_));
+  if (!this->RccFileTime_.Load(this->RccFileOutput_)) {
+    if (this->Log().Verbose()) {
+      this->Reason =
+        cmStrCat("Generating ", this->MessagePath(this->RccFileOutput_),
+                 ", because it doesn't exist, from ",
+                 this->MessagePath(this->QrcFile_));
     }
     generate = true;
     return true;
   }
 
   // Test if the settings changed
-  if (SettingsChanged_) {
-    if (Log().Verbose()) {
-      Reason = cmStrCat("Generating ", MessagePath(RccFileOutput_),
-                        ", because the rcc settings changed, from ",
-                        MessagePath(QrcFile_));
+  if (this->SettingsChanged_) {
+    if (this->Log().Verbose()) {
+      this->Reason =
+        cmStrCat("Generating ", this->MessagePath(this->RccFileOutput_),
+                 ", because the rcc settings changed, from ",
+                 this->MessagePath(this->QrcFile_));
     }
     generate = true;
     return true;
   }
 
   // Test if the rcc output file is older than the .qrc file
-  if (RccFileTime_.Older(QrcFileTime_)) {
-    if (Log().Verbose()) {
-      Reason = cmStrCat("Generating ", MessagePath(RccFileOutput_),
-                        ", because it is older than ", MessagePath(QrcFile_),
-                        ", from ", MessagePath(QrcFile_));
+  if (this->RccFileTime_.Older(this->QrcFileTime_)) {
+    if (this->Log().Verbose()) {
+      this->Reason = cmStrCat(
+        "Generating ", this->MessagePath(this->RccFileOutput_),
+        ", because it is older than ", this->MessagePath(this->QrcFile_),
+        ", from ", this->MessagePath(this->QrcFile_));
     }
     generate = true;
     return true;
   }
 
   // Test if the rcc output file is older than the rcc executable
-  if (RccFileTime_.Older(RccExecutableTime_)) {
-    if (Log().Verbose()) {
-      Reason = cmStrCat("Generating ", MessagePath(RccFileOutput_),
-                        ", because it is older than the rcc executable, from ",
-                        MessagePath(QrcFile_));
+  if (this->RccFileTime_.Older(this->RccExecutableTime_)) {
+    if (this->Log().Verbose()) {
+      this->Reason =
+        cmStrCat("Generating ", this->MessagePath(this->RccFileOutput_),
+                 ", because it is older than the rcc executable, from ",
+                 this->MessagePath(this->QrcFile_));
     }
     generate = true;
     return true;
@@ -334,34 +349,38 @@ bool cmQtAutoRccT::TestQrcRccFiles(bool& generate)
 bool cmQtAutoRccT::TestResources(bool& generate)
 {
   // Read resource files list
-  if (Inputs_.empty()) {
+  if (this->Inputs_.empty()) {
     std::string error;
-    RccLister const lister(RccExecutable_, RccListOptions_);
-    if (!lister.list(QrcFile_, Inputs_, error, Log().Verbose())) {
-      Log().Error(
-        GenT::RCC,
-        cmStrCat("Listing of ", MessagePath(QrcFile_), " failed.\n", error));
+    RccLister const lister(this->RccExecutable_, this->RccListOptions_);
+    if (!lister.list(this->QrcFile_, this->Inputs_, error,
+                     this->Log().Verbose())) {
+      this->Log().Error(GenT::RCC,
+                        cmStrCat("Listing of ",
+                                 this->MessagePath(this->QrcFile_),
+                                 " failed.\n", error));
       return false;
     }
   }
 
   // Check if any resource file is newer than the rcc output file
-  for (std::string const& resFile : Inputs_) {
+  for (std::string const& resFile : this->Inputs_) {
     // Check if the resource file exists
     cmFileTime fileTime;
     if (!fileTime.Load(resFile)) {
-      Log().Error(GenT::RCC,
-                  cmStrCat("The resource file ", MessagePath(resFile),
-                           " listed in ", MessagePath(QrcFile_),
-                           " does not exist."));
+      this->Log().Error(GenT::RCC,
+                        cmStrCat("The resource file ",
+                                 this->MessagePath(resFile), " listed in ",
+                                 this->MessagePath(this->QrcFile_),
+                                 " does not exist."));
       return false;
     }
     // Check if the resource file is newer than the rcc output file
-    if (RccFileTime_.Older(fileTime)) {
-      if (Log().Verbose()) {
-        Reason = cmStrCat("Generating ", MessagePath(RccFileOutput_),
-                          ", because it is older than ", MessagePath(resFile),
-                          ", from ", MessagePath(QrcFile_));
+    if (this->RccFileTime_.Older(fileTime)) {
+      if (this->Log().Verbose()) {
+        this->Reason =
+          cmStrCat("Generating ", this->MessagePath(this->RccFileOutput_),
+                   ", because it is older than ", this->MessagePath(resFile),
+                   ", from ", this->MessagePath(this->QrcFile_));
       }
       generate = true;
       break;
@@ -373,21 +392,23 @@ bool cmQtAutoRccT::TestResources(bool& generate)
 bool cmQtAutoRccT::TestInfoFile()
 {
   // Test if the rcc output file is older than the info file
-  if (RccFileTime_.Older(InfoFileTime())) {
-    if (Log().Verbose()) {
-      Log().Info(GenT::RCC,
-                 cmStrCat("Touching ", MessagePath(RccFileOutput_),
-                          " because it is older than ",
-                          MessagePath(InfoFile())));
+  if (this->RccFileTime_.Older(this->InfoFileTime())) {
+    if (this->Log().Verbose()) {
+      this->Log().Info(GenT::RCC,
+                       cmStrCat("Touching ",
+                                this->MessagePath(this->RccFileOutput_),
+                                " because it is older than ",
+                                this->MessagePath(this->InfoFile())));
     }
     // Touch build file
-    if (!cmSystemTools::Touch(RccFileOutput_, false)) {
-      Log().Error(
-        GenT::RCC,
-        cmStrCat("Touching ", MessagePath(RccFileOutput_), " failed."));
+    if (!cmSystemTools::Touch(this->RccFileOutput_, false)) {
+      this->Log().Error(GenT::RCC,
+                        cmStrCat("Touching ",
+                                 this->MessagePath(this->RccFileOutput_),
+                                 " failed."));
       return false;
     }
-    BuildFileChanged_ = true;
+    this->BuildFileChanged_ = true;
   }
 
   return true;
@@ -396,51 +417,53 @@ bool cmQtAutoRccT::TestInfoFile()
 bool cmQtAutoRccT::GenerateRcc()
 {
   // Make parent directory
-  if (!MakeParentDirectory(RccFileOutput_)) {
-    Log().Error(GenT::RCC,
-                cmStrCat("Could not create parent directory of ",
-                         MessagePath(RccFileOutput_)));
+  if (!MakeParentDirectory(this->RccFileOutput_)) {
+    this->Log().Error(GenT::RCC,
+                      cmStrCat("Could not create parent directory of ",
+                               this->MessagePath(this->RccFileOutput_)));
     return false;
   }
 
   // Compose rcc command
   std::vector<std::string> cmd;
-  cmd.push_back(RccExecutable_);
-  cm::append(cmd, Options_);
+  cmd.push_back(this->RccExecutable_);
+  cm::append(cmd, this->Options_);
   cmd.emplace_back("-o");
-  cmd.push_back(RccFileOutput_);
-  cmd.push_back(QrcFile_);
+  cmd.push_back(this->RccFileOutput_);
+  cmd.push_back(this->QrcFile_);
 
   // Log reason and command
-  if (Log().Verbose()) {
-    Log().Info(GenT::RCC,
-               cmStrCat(Reason, cmHasSuffix(Reason, '\n') ? "" : "\n",
-                        QuotedCommand(cmd), '\n'));
+  if (this->Log().Verbose()) {
+    this->Log().Info(GenT::RCC,
+                     cmStrCat(this->Reason,
+                              cmHasSuffix(this->Reason, '\n') ? "" : "\n",
+                              QuotedCommand(cmd), '\n'));
   }
 
   std::string rccStdOut;
   std::string rccStdErr;
   int retVal = 0;
   bool result = cmSystemTools::RunSingleCommand(
-    cmd, &rccStdOut, &rccStdErr, &retVal, AutogenBuildDir_.c_str(),
+    cmd, &rccStdOut, &rccStdErr, &retVal, this->AutogenBuildDir_.c_str(),
     cmSystemTools::OUTPUT_NONE, cmDuration::zero(), cmProcessOutput::Auto);
   if (!result || (retVal != 0)) {
     // rcc process failed
-    Log().ErrorCommand(GenT::RCC,
-                       cmStrCat("The rcc process failed to compile\n  ",
-                                MessagePath(QrcFile_), "\ninto\n  ",
-                                MessagePath(RccFileOutput_)),
-                       cmd, rccStdOut + rccStdErr);
-    cmSystemTools::RemoveFile(RccFileOutput_);
+    this->Log().ErrorCommand(GenT::RCC,
+                             cmStrCat("The rcc process failed to compile\n  ",
+                                      this->MessagePath(this->QrcFile_),
+                                      "\ninto\n  ",
+                                      this->MessagePath(this->RccFileOutput_)),
+                             cmd, rccStdOut + rccStdErr);
+    cmSystemTools::RemoveFile(this->RccFileOutput_);
     return false;
   }
 
   // rcc process success
   // Print rcc output
   if (!rccStdOut.empty()) {
-    Log().Info(GenT::RCC, rccStdOut);
+    this->Log().Info(GenT::RCC, rccStdOut);
   }
-  BuildFileChanged_ = true;
+  this->BuildFileChanged_ = true;
 
   return true;
 }
@@ -448,47 +471,48 @@ bool cmQtAutoRccT::GenerateRcc()
 bool cmQtAutoRccT::GenerateWrapper()
 {
   // Generate a wrapper source file on demand
-  if (IsMultiConfig()) {
+  if (this->IsMultiConfig()) {
     // Wrapper file content
     std::string content =
       cmStrCat("// This is an autogenerated configuration wrapper file.\n",
                "// Changes will be overwritten.\n", "#include <",
-               MultiConfigOutput(), ">\n");
+               this->MultiConfigOutput(), ">\n");
 
     // Compare with existing file content
     bool fileDiffers = true;
     {
       std::string oldContents;
-      if (FileRead(oldContents, RccFilePublic_)) {
+      if (FileRead(oldContents, this->RccFilePublic_)) {
         fileDiffers = (oldContents != content);
       }
     }
     if (fileDiffers) {
       // Write new wrapper file
-      if (Log().Verbose()) {
-        Log().Info(GenT::RCC,
-                   cmStrCat("Generating RCC wrapper file ",
-                            MessagePath(RccFilePublic_)));
+      if (this->Log().Verbose()) {
+        this->Log().Info(GenT::RCC,
+                         cmStrCat("Generating RCC wrapper file ",
+                                  this->MessagePath(this->RccFilePublic_)));
       }
       std::string error;
-      if (!FileWrite(RccFilePublic_, content, &error)) {
-        Log().Error(GenT::RCC,
-                    cmStrCat("Generating RCC wrapper file ",
-                             MessagePath(RccFilePublic_), " failed.\n",
-                             error));
+      if (!FileWrite(this->RccFilePublic_, content, &error)) {
+        this->Log().Error(GenT::RCC,
+                          cmStrCat("Generating RCC wrapper file ",
+                                   this->MessagePath(this->RccFilePublic_),
+                                   " failed.\n", error));
         return false;
       }
-    } else if (BuildFileChanged_) {
+    } else if (this->BuildFileChanged_) {
       // Just touch the wrapper file
-      if (Log().Verbose()) {
-        Log().Info(
-          GenT::RCC,
-          cmStrCat("Touching RCC wrapper file ", MessagePath(RccFilePublic_)));
+      if (this->Log().Verbose()) {
+        this->Log().Info(GenT::RCC,
+                         cmStrCat("Touching RCC wrapper file ",
+                                  this->MessagePath(this->RccFilePublic_)));
       }
-      if (!cmSystemTools::Touch(RccFilePublic_, false)) {
-        Log().Error(GenT::RCC,
-                    cmStrCat("Touching RCC wrapper file ",
-                             MessagePath(RccFilePublic_), " failed."));
+      if (!cmSystemTools::Touch(this->RccFilePublic_, false)) {
+        this->Log().Error(GenT::RCC,
+                          cmStrCat("Touching RCC wrapper file ",
+                                   this->MessagePath(this->RccFilePublic_),
+                                   " failed."));
         return false;
       }
     }
diff --git a/Source/cmState.cxx b/Source/cmState.cxx
index 3692a01399..0fd79012c2 100644
--- a/Source/cmState.cxx
+++ b/Source/cmState.cxx
@@ -524,7 +524,7 @@ bool cmState::AddScriptedCommand(std::string const& name, BT<Command> command,
 
 cmState::Command cmState::GetCommand(std::string const& name) const
 {
-  return GetCommandByExactName(cmSystemTools::LowerCase(name));
+  return this->GetCommandByExactName(cmSystemTools::LowerCase(name));
 }
 
 cmState::Command cmState::GetCommandByExactName(std::string const& name) const
diff --git a/Source/cmStateDirectory.cxx b/Source/cmStateDirectory.cxx
index 796bb1f754..7ce362a584 100644
--- a/Source/cmStateDirectory.cxx
+++ b/Source/cmStateDirectory.cxx
@@ -148,11 +148,13 @@ bool cmStateDirectory::ContainsBoth(std::string const& local_path,
             cmSystemTools::IsSubDirectory(a, b));
   };
 
-  bool bothInBinary = PathEqOrSubDir(local_path, GetRelativePathTopBinary()) &&
-    PathEqOrSubDir(remote_path, GetRelativePathTopBinary());
+  bool bothInBinary =
+    PathEqOrSubDir(local_path, this->GetRelativePathTopBinary()) &&
+    PathEqOrSubDir(remote_path, this->GetRelativePathTopBinary());
 
-  bool bothInSource = PathEqOrSubDir(local_path, GetRelativePathTopSource()) &&
-    PathEqOrSubDir(remote_path, GetRelativePathTopSource());
+  bool bothInSource =
+    PathEqOrSubDir(local_path, this->GetRelativePathTopSource()) &&
+    PathEqOrSubDir(remote_path, this->GetRelativePathTopSource());
 
   return bothInBinary || bothInSource;
 }
diff --git a/Source/cmString.cxx b/Source/cmString.cxx
index 898b8286e5..87212426f5 100644
--- a/Source/cmString.cxx
+++ b/Source/cmString.cxx
@@ -19,17 +19,17 @@ void String::internally_mutate_to_stable_string()
   // We assume that only one thread mutates this instance at
   // a time even if we point to a shared string buffer referenced
   // by other threads.
-  *this = String(data(), size());
+  *this = String(this->data(), this->size());
 }
 
 bool String::is_stable() const
 {
-  return str_if_stable() != nullptr;
+  return this->str_if_stable() != nullptr;
 }
 
 void String::stabilize()
 {
-  if (is_stable()) {
+  if (this->is_stable()) {
     return;
   }
   this->internally_mutate_to_stable_string();
@@ -37,16 +37,17 @@ void String::stabilize()
 
 std::string const* String::str_if_stable() const
 {
-  if (!data()) {
+  if (!this->data()) {
     // We view no string.
     // This is stable for the lifetime of our current value.
     return &empty_string_;
   }
 
-  if (string_ && data() == string_->data() && size() == string_->size()) {
+  if (this->string_ && this->data() == this->string_->data() &&
+      this->size() == this->string_->size()) {
     // We view an entire string.
     // This is stable for the lifetime of our current value.
-    return string_.get();
+    return this->string_.get();
   }
 
   return nullptr;
@@ -54,18 +55,18 @@ std::string const* String::str_if_stable() const
 
 std::string const& String::str()
 {
-  if (std::string const* s = str_if_stable()) {
+  if (std::string const* s = this->str_if_stable()) {
     return *s;
   }
   // Mutate to hold a std::string that is stable for the lifetime
   // of our current value.
   this->internally_mutate_to_stable_string();
-  return *string_;
+  return *this->string_;
 }
 
 const char* String::c_str()
 {
-  const char* c = data();
+  const char* c = this->data();
   if (c == nullptr) {
     return c;
   }
@@ -73,42 +74,42 @@ const char* String::c_str()
   // We always point into a null-terminated string so it is safe to
   // access one past the end.  If it is a null byte then we can use
   // the pointer directly.
-  if (c[size()] == '\0') {
+  if (c[this->size()] == '\0') {
     return c;
   }
 
   // Mutate to hold a std::string so we can get a null terminator.
   this->internally_mutate_to_stable_string();
-  c = string_->c_str();
+  c = this->string_->c_str();
   return c;
 }
 
 String& String::insert(size_type index, size_type count, char ch)
 {
   std::string s;
-  s.reserve(size() + count);
-  s.assign(data(), size());
+  s.reserve(this->size() + count);
+  s.assign(this->data(), this->size());
   s.insert(index, count, ch);
   return *this = std::move(s);
 }
 
 String& String::erase(size_type index, size_type count)
 {
-  if (index > size()) {
+  if (index > this->size()) {
     throw std::out_of_range("Index out of range in String::erase");
   }
-  size_type const rcount = std::min(count, size() - index);
+  size_type const rcount = std::min(count, this->size() - index);
   size_type const rindex = index + rcount;
   std::string s;
-  s.reserve(size() - rcount);
-  s.assign(data(), index);
-  s.append(data() + rindex, size() - rindex);
+  s.reserve(this->size() - rcount);
+  s.assign(this->data(), index);
+  s.append(this->data() + rindex, this->size() - rindex);
   return *this = std::move(s);
 }
 
 String String::substr(size_type pos, size_type count) const
 {
-  if (pos > size()) {
+  if (pos > this->size()) {
     throw std::out_of_range("Index out of range in String::substr");
   }
   return String(*this, pos, count);
@@ -116,14 +117,14 @@ String String::substr(size_type pos, size_type count) const
 
 String::String(std::string&& s, Private)
   : string_(std::make_shared<std::string>(std::move(s)))
-  , view_(string_->data(), string_->size())
+  , view_(this->string_->data(), this->string_->size())
 {
 }
 
 String::size_type String::copy(char* dest, size_type count,
                                size_type pos) const
 {
-  return view_.copy(dest, count, pos);
+  return this->view_.copy(dest, count, pos);
 }
 
 std::ostream& operator<<(std::ostream& os, String const& s)
diff --git a/Source/cmString.hxx b/Source/cmString.hxx
index b41b9605b8..f1e462bb2c 100644
--- a/Source/cmString.hxx
+++ b/Source/cmString.hxx
@@ -301,8 +301,8 @@ public:
       The other instance is left as a null string.  */
   String& operator=(String&& s) noexcept
   {
-    string_ = std::move(s.string_);
-    view_ = s.view_;
+    this->string_ = std::move(s.string_);
+    this->view_ = s.view_;
     s.view_ = string_view();
     return *this;
   }
@@ -340,33 +340,33 @@ public:
   }
 
   /** Return true if the instance is not a null string.  */
-  explicit operator bool() const noexcept { return data() != nullptr; }
+  explicit operator bool() const noexcept { return this->data() != nullptr; }
 
   /** Return a view of the string.  */
-  string_view view() const noexcept { return view_; }
+  string_view view() const noexcept { return this->view_; }
   operator string_view() const noexcept { return this->view(); }
 
   /** Return true if the instance is an empty stringn or null string.  */
-  bool empty() const noexcept { return view_.empty(); }
+  bool empty() const noexcept { return this->view_.empty(); }
 
   /** Return a pointer to the start of the string.  */
-  const char* data() const noexcept { return view_.data(); }
+  const char* data() const noexcept { return this->view_.data(); }
 
   /** Return the length of the string in bytes.  */
-  size_type size() const noexcept { return view_.size(); }
-  size_type length() const noexcept { return view_.length(); }
+  size_type size() const noexcept { return this->view_.size(); }
+  size_type length() const noexcept { return this->view_.length(); }
 
   /** Return the character at the given position.
       No bounds checking is performed.  */
-  char operator[](size_type pos) const noexcept { return view_[pos]; }
+  char operator[](size_type pos) const noexcept { return this->view_[pos]; }
 
   /** Return the character at the given position.
       If the position is out of bounds, throws std::out_of_range.  */
-  char at(size_type pos) const { return view_.at(pos); }
+  char at(size_type pos) const { return this->view_.at(pos); }
 
-  char front() const noexcept { return view_.front(); }
+  char front() const noexcept { return this->view_.front(); }
 
-  char back() const noexcept { return view_.back(); }
+  char back() const noexcept { return this->view_.back(); }
 
   /** Return true if this instance is stable and otherwise false.
       An instance is stable if it is in the 'null' state or if it is
@@ -392,15 +392,18 @@ public:
       or str() is called.  */
   const char* c_str();
 
-  const_iterator begin() const noexcept { return view_.begin(); }
-  const_iterator end() const noexcept { return view_.end(); }
-  const_iterator cbegin() const noexcept { return begin(); }
-  const_iterator cend() const noexcept { return end(); }
+  const_iterator begin() const noexcept { return this->view_.begin(); }
+  const_iterator end() const noexcept { return this->view_.end(); }
+  const_iterator cbegin() const noexcept { return this->begin(); }
+  const_iterator cend() const noexcept { return this->end(); }
 
-  const_reverse_iterator rbegin() const noexcept { return view_.rbegin(); }
-  const_reverse_iterator rend() const noexcept { return view_.rend(); }
-  const_reverse_iterator crbegin() const noexcept { return rbegin(); }
-  const_reverse_iterator crend() const noexcept { return rend(); }
+  const_reverse_iterator rbegin() const noexcept
+  {
+    return this->view_.rbegin();
+  }
+  const_reverse_iterator rend() const noexcept { return this->view_.rend(); }
+  const_reverse_iterator crbegin() const noexcept { return this->rbegin(); }
+  const_reverse_iterator crend() const noexcept { return this->rend(); }
 
   /** Append to the string using any type that implements the
       AsStringView trait.  */
@@ -410,8 +413,8 @@ public:
   {
     string_view v = AsStringView<T>::view(std::forward<T>(s));
     std::string r;
-    r.reserve(size() + v.size());
-    r.assign(data(), size());
+    r.reserve(this->size() + v.size());
+    r.assign(this->data(), this->size());
     r.append(v.data(), v.size());
     return *this = std::move(r);
   }
@@ -428,21 +431,21 @@ public:
   void push_back(char ch)
   {
     std::string s;
-    s.reserve(size() + 1);
-    s.assign(data(), size());
+    s.reserve(this->size() + 1);
+    s.assign(this->data(), this->size());
     s.push_back(ch);
     *this = std::move(s);
   }
 
-  void pop_back() { *this = String(*this, 0, size() - 1); }
+  void pop_back() { *this = String(*this, 0, this->size() - 1); }
 
   template <typename T>
   typename std::enable_if<AsStringView<T>::value, String&>::type replace(
     size_type pos, size_type count, T&& s)
   {
-    const_iterator first = begin() + pos;
+    const_iterator first = this->begin() + pos;
     const_iterator last = first + count;
-    return replace(first, last, std::forward<T>(s));
+    return this->replace(first, last, std::forward<T>(s));
   }
 
   template <typename InputIterator>
@@ -450,9 +453,9 @@ public:
                   InputIterator first2, InputIterator last2)
   {
     std::string out;
-    out.append(view_.begin(), first);
+    out.append(this->view_.begin(), first);
     out.append(first2, last2);
-    out.append(last, view_.end());
+    out.append(last, this->view_.end());
     return *this = std::move(out);
   }
 
@@ -462,10 +465,11 @@ public:
   {
     string_view v = AsStringView<T>::view(std::forward<T>(s));
     std::string out;
-    out.reserve((first - view_.begin()) + v.size() + (view_.end() - last));
-    out.append(view_.begin(), first);
+    out.reserve((first - this->view_.begin()) + v.size() +
+                (this->view_.end() - last));
+    out.append(this->view_.begin(), first);
     out.append(v.data(), v.size());
-    out.append(last, view_.end());
+    out.append(last, this->view_.end());
     return *this = std::move(out);
   }
 
@@ -476,39 +480,40 @@ public:
   {
     string_view v = AsStringView<T>::view(std::forward<T>(s));
     v = v.substr(pos2, count2);
-    return replace(pos, count, v);
+    return this->replace(pos, count, v);
   }
 
   String& replace(size_type pos, size_type count, size_type count2, char ch)
   {
-    const_iterator first = begin() + pos;
+    const_iterator first = this->begin() + pos;
     const_iterator last = first + count;
-    return replace(first, last, count2, ch);
+    return this->replace(first, last, count2, ch);
   }
 
   String& replace(const_iterator first, const_iterator last, size_type count2,
                   char ch)
   {
     std::string out;
-    out.reserve((first - view_.begin()) + count2 + (view_.end() - last));
-    out.append(view_.begin(), first);
+    out.reserve((first - this->view_.begin()) + count2 +
+                (this->view_.end() - last));
+    out.append(this->view_.begin(), first);
     out.append(count2, ch);
-    out.append(last, view_.end());
+    out.append(last, this->view_.end());
     return *this = std::move(out);
   }
 
   size_type copy(char* dest, size_type count, size_type pos = 0) const;
 
-  void resize(size_type count) { resize(count, char()); }
+  void resize(size_type count) { this->resize(count, char()); }
 
   void resize(size_type count, char ch)
   {
     std::string s;
     s.reserve(count);
-    if (count <= size()) {
-      s.assign(data(), count);
+    if (count <= this->size()) {
+      s.assign(this->data(), count);
     } else {
-      s.assign(data(), size());
+      s.assign(this->data(), this->size());
       s.resize(count, ch);
     }
     *this = std::move(s);
@@ -516,8 +521,8 @@ public:
 
   void swap(String& other)
   {
-    std::swap(string_, other.string_);
-    std::swap(view_, other.view_);
+    std::swap(this->string_, other.string_);
+    std::swap(this->view_, other.view_);
   }
 
   /** Return a substring starting at position 'pos' and
@@ -528,29 +533,29 @@ public:
   typename std::enable_if<AsStringView<T>::value, int>::type compare(
     T&& s) const
   {
-    return view_.compare(AsStringView<T>::view(std::forward<T>(s)));
+    return this->view_.compare(AsStringView<T>::view(std::forward<T>(s)));
   }
 
   int compare(size_type pos1, size_type count1, string_view v) const
   {
-    return view_.compare(pos1, count1, v);
+    return this->view_.compare(pos1, count1, v);
   }
 
   int compare(size_type pos1, size_type count1, string_view v, size_type pos2,
               size_type count2) const
   {
-    return view_.compare(pos1, count1, v, pos2, count2);
+    return this->view_.compare(pos1, count1, v, pos2, count2);
   }
 
   int compare(size_type pos1, size_type count1, const char* s) const
   {
-    return view_.compare(pos1, count1, s);
+    return this->view_.compare(pos1, count1, s);
   }
 
   int compare(size_type pos1, size_type count1, const char* s,
               size_type count2) const
   {
-    return view_.compare(pos1, count1, s, count2);
+    return this->view_.compare(pos1, count1, s, count2);
   }
 
   template <typename T>
@@ -558,12 +563,12 @@ public:
     T&& s, size_type pos = 0) const
   {
     string_view v = AsStringView<T>::view(std::forward<T>(s));
-    return view_.find(v, pos);
+    return this->view_.find(v, pos);
   }
 
   size_type find(const char* s, size_type pos, size_type count) const
   {
-    return view_.find(s, pos, count);
+    return this->view_.find(s, pos, count);
   }
 
   template <typename T>
@@ -571,12 +576,12 @@ public:
     T&& s, size_type pos = npos) const
   {
     string_view v = AsStringView<T>::view(std::forward<T>(s));
-    return view_.rfind(v, pos);
+    return this->view_.rfind(v, pos);
   }
 
   size_type rfind(const char* s, size_type pos, size_type count) const
   {
-    return view_.rfind(s, pos, count);
+    return this->view_.rfind(s, pos, count);
   }
 
   template <typename T>
@@ -584,12 +589,12 @@ public:
   find_first_of(T&& s, size_type pos = 0) const
   {
     string_view v = AsStringView<T>::view(std::forward<T>(s));
-    return view_.find_first_of(v, pos);
+    return this->view_.find_first_of(v, pos);
   }
 
   size_type find_first_of(const char* s, size_type pos, size_type count) const
   {
-    return view_.find_first_of(s, pos, count);
+    return this->view_.find_first_of(s, pos, count);
   }
 
   template <typename T>
@@ -597,13 +602,13 @@ public:
   find_first_not_of(T&& s, size_type pos = 0) const
   {
     string_view v = AsStringView<T>::view(std::forward<T>(s));
-    return view_.find_first_not_of(v, pos);
+    return this->view_.find_first_not_of(v, pos);
   }
 
   size_type find_first_not_of(const char* s, size_type pos,
                               size_type count) const
   {
-    return view_.find_first_not_of(s, pos, count);
+    return this->view_.find_first_not_of(s, pos, count);
   }
 
   template <typename T>
@@ -611,12 +616,12 @@ public:
   find_last_of(T&& s, size_type pos = npos) const
   {
     string_view v = AsStringView<T>::view(std::forward<T>(s));
-    return view_.find_last_of(v, pos);
+    return this->view_.find_last_of(v, pos);
   }
 
   size_type find_last_of(const char* s, size_type pos, size_type count) const
   {
-    return view_.find_last_of(s, pos, count);
+    return this->view_.find_last_of(s, pos, count);
   }
 
   template <typename T>
@@ -624,13 +629,13 @@ public:
   find_last_not_of(T&& s, size_type pos = npos) const
   {
     string_view v = AsStringView<T>::view(std::forward<T>(s));
-    return view_.find_last_not_of(v, pos);
+    return this->view_.find_last_not_of(v, pos);
   }
 
   size_type find_last_not_of(const char* s, size_type pos,
                              size_type count) const
   {
-    return view_.find_last_not_of(s, pos, count);
+    return this->view_.find_last_not_of(s, pos, count);
   }
 
 private:
@@ -822,7 +827,10 @@ struct StringOpPlus
   }
 #endif
   operator std::string() const;
-  std::string::size_type size() const { return l.size() + r.size(); }
+  std::string::size_type size() const
+  {
+    return this->l.size() + this->r.size();
+  }
 };
 
 template <typename T>
@@ -848,7 +856,7 @@ template <typename L, typename R>
 StringOpPlus<L, R>::operator std::string() const
 {
   std::string s;
-  s.reserve(size());
+  s.reserve(this->size());
   s += *this;
   return s;
 }
diff --git a/Source/cmStringAlgorithms.cxx b/Source/cmStringAlgorithms.cxx
index e0af28185a..fb0b705c4c 100644
--- a/Source/cmStringAlgorithms.cxx
+++ b/Source/cmStringAlgorithms.cxx
@@ -161,42 +161,42 @@ inline void MakeDigits(cm::string_view& view, char (&digits)[N],
 
 cmAlphaNum::cmAlphaNum(int val)
 {
-  MakeDigits(View_, Digits_, "%i", val);
+  MakeDigits(this->View_, this->Digits_, "%i", val);
 }
 
 cmAlphaNum::cmAlphaNum(unsigned int val)
 {
-  MakeDigits(View_, Digits_, "%u", val);
+  MakeDigits(this->View_, this->Digits_, "%u", val);
 }
 
 cmAlphaNum::cmAlphaNum(long int val)
 {
-  MakeDigits(View_, Digits_, "%li", val);
+  MakeDigits(this->View_, this->Digits_, "%li", val);
 }
 
 cmAlphaNum::cmAlphaNum(unsigned long int val)
 {
-  MakeDigits(View_, Digits_, "%lu", val);
+  MakeDigits(this->View_, this->Digits_, "%lu", val);
 }
 
 cmAlphaNum::cmAlphaNum(long long int val)
 {
-  MakeDigits(View_, Digits_, "%lli", val);
+  MakeDigits(this->View_, this->Digits_, "%lli", val);
 }
 
 cmAlphaNum::cmAlphaNum(unsigned long long int val)
 {
-  MakeDigits(View_, Digits_, "%llu", val);
+  MakeDigits(this->View_, this->Digits_, "%llu", val);
 }
 
 cmAlphaNum::cmAlphaNum(float val)
 {
-  MakeDigits(View_, Digits_, "%g", static_cast<double>(val));
+  MakeDigits(this->View_, this->Digits_, "%g", static_cast<double>(val));
 }
 
 cmAlphaNum::cmAlphaNum(double val)
 {
-  MakeDigits(View_, Digits_, "%g", val);
+  MakeDigits(this->View_, this->Digits_, "%g", val);
 }
 
 std::string cmCatViews(std::initializer_list<cm::string_view> views)
diff --git a/Source/cmStringAlgorithms.h b/Source/cmStringAlgorithms.h
index 01e3d940ec..6b458ec52c 100644
--- a/Source/cmStringAlgorithms.h
+++ b/Source/cmStringAlgorithms.h
@@ -48,7 +48,7 @@ struct cmStrCmp
   {
   }
 
-  bool operator()(cm::string_view sv) const { return Test_ == sv; }
+  bool operator()(cm::string_view sv) const { return this->Test_ == sv; }
 
 private:
   std::string const Test_;
@@ -163,9 +163,9 @@ public:
   {
   }
   cmAlphaNum(char ch)
-    : View_(Digits_, 1)
+    : View_(this->Digits_, 1)
   {
-    Digits_[0] = ch;
+    this->Digits_[0] = ch;
   }
   cmAlphaNum(int val);
   cmAlphaNum(unsigned int val);
@@ -176,7 +176,7 @@ public:
   cmAlphaNum(float val);
   cmAlphaNum(double val);
 
-  cm::string_view View() const { return View_; }
+  cm::string_view View() const { return this->View_; }
 
 private:
   cm::string_view View_;
diff --git a/Source/cmStringCommand.cxx b/Source/cmStringCommand.cxx
index b28fca954c..0c8adc72a7 100644
--- a/Source/cmStringCommand.cxx
+++ b/Source/cmStringCommand.cxx
@@ -966,21 +966,21 @@ public:
 
 const std::string& Args::PopFront(cm::string_view error)
 {
-  if (empty()) {
+  if (this->empty()) {
     throw json_error({ error });
   }
-  const std::string& res = *begin();
-  advance(1);
+  const std::string& res = *this->begin();
+  this->advance(1);
   return res;
 }
 
 const std::string& Args::PopBack(cm::string_view error)
 {
-  if (empty()) {
+  if (this->empty()) {
     throw json_error({ error });
   }
-  const std::string& res = *(end() - 1);
-  retreat(1);
+  const std::string& res = *(this->end() - 1);
+  this->retreat(1);
   return res;
 }
 
diff --git a/Source/cmTarget.cxx b/Source/cmTarget.cxx
index 017ab10bfc..2fd606309f 100644
--- a/Source/cmTarget.cxx
+++ b/Source/cmTarget.cxx
@@ -230,34 +230,35 @@ cmTarget::cmTarget(std::string const& name, cmStateEnums::TargetType type,
   : impl(cm::make_unique<cmTargetInternals>())
 {
   assert(mf);
-  impl->TargetType = type;
-  impl->Makefile = mf;
-  impl->Name = name;
-  impl->IsGeneratorProvided = false;
-  impl->HaveInstallRule = false;
-  impl->IsDLLPlatform = false;
-  impl->IsAIX = false;
-  impl->IsAndroid = false;
-  impl->IsImportedTarget =
+  this->impl->TargetType = type;
+  this->impl->Makefile = mf;
+  this->impl->Name = name;
+  this->impl->IsGeneratorProvided = false;
+  this->impl->HaveInstallRule = false;
+  this->impl->IsDLLPlatform = false;
+  this->impl->IsAIX = false;
+  this->impl->IsAndroid = false;
+  this->impl->IsImportedTarget =
     (vis == VisibilityImported || vis == VisibilityImportedGlobally);
-  impl->ImportedGloballyVisible = vis == VisibilityImportedGlobally;
-  impl->BuildInterfaceIncludesAppended = false;
-  impl->PerConfig = (perConfig == PerConfig::Yes);
+  this->impl->ImportedGloballyVisible = vis == VisibilityImportedGlobally;
+  this->impl->BuildInterfaceIncludesAppended = false;
+  this->impl->PerConfig = (perConfig == PerConfig::Yes);
 
   // Check whether this is a DLL platform.
-  impl->IsDLLPlatform =
-    !impl->Makefile->GetSafeDefinition("CMAKE_IMPORT_LIBRARY_SUFFIX").empty();
+  this->impl->IsDLLPlatform =
+    !this->impl->Makefile->GetSafeDefinition("CMAKE_IMPORT_LIBRARY_SUFFIX")
+       .empty();
 
   // Check whether we are targeting AIX.
   {
     std::string const& systemName =
-      impl->Makefile->GetSafeDefinition("CMAKE_SYSTEM_NAME");
-    impl->IsAIX = (systemName == "AIX" || systemName == "OS400");
+      this->impl->Makefile->GetSafeDefinition("CMAKE_SYSTEM_NAME");
+    this->impl->IsAIX = (systemName == "AIX" || systemName == "OS400");
   }
 
   // Check whether we are targeting an Android platform.
-  impl->IsAndroid =
-    (impl->Makefile->GetSafeDefinition("CMAKE_SYSTEM_NAME") == "Android");
+  this->impl->IsAndroid = (this->impl->Makefile->GetSafeDefinition(
+                             "CMAKE_SYSTEM_NAME") == "Android");
 
   std::string defKey;
   defKey.reserve(128);
@@ -436,7 +437,7 @@ cmTarget::cmTarget(std::string const& name, cmStateEnums::TargetType type,
       for (auto const& prop : configProps) {
         // Interface libraries have no output locations, so honor only
         // the configuration map.
-        if (impl->TargetType == cmStateEnums::INTERFACE_LIBRARY &&
+        if (this->impl->TargetType == cmStateEnums::INTERFACE_LIBRARY &&
             strcmp(prop, "MAP_IMPORTED_CONFIG_") != 0) {
           continue;
         }
@@ -449,15 +450,15 @@ cmTarget::cmTarget(std::string const& name, cmStateEnums::TargetType type,
       // compatibility with previous CMake versions in which executables
       // did not support this variable.  Projects may still specify the
       // property directly.
-      if (impl->TargetType != cmStateEnums::EXECUTABLE &&
-          impl->TargetType != cmStateEnums::INTERFACE_LIBRARY) {
+      if (this->impl->TargetType != cmStateEnums::EXECUTABLE &&
+          this->impl->TargetType != cmStateEnums::INTERFACE_LIBRARY) {
         std::string property =
           cmStrCat(cmSystemTools::UpperCase(configName), "_POSTFIX");
         initProp(property);
       }
 
-      if (impl->TargetType == cmStateEnums::SHARED_LIBRARY ||
-          impl->TargetType == cmStateEnums::STATIC_LIBRARY) {
+      if (this->impl->TargetType == cmStateEnums::SHARED_LIBRARY ||
+          this->impl->TargetType == cmStateEnums::STATIC_LIBRARY) {
         std::string property = cmStrCat("FRAMEWORK_MULTI_CONFIG_POSTFIX_",
                                         cmSystemTools::UpperCase(configName));
         initProp(property);
@@ -466,66 +467,67 @@ cmTarget::cmTarget(std::string const& name, cmStateEnums::TargetType type,
   }
 
   // Save the backtrace of target construction.
-  impl->Backtrace = impl->Makefile->GetBacktrace();
+  this->impl->Backtrace = this->impl->Makefile->GetBacktrace();
 
   if (!this->IsImported()) {
     // Initialize the INCLUDE_DIRECTORIES property based on the current value
     // of the same directory property:
-    cm::append(impl->IncludeDirectoriesEntries,
-               impl->Makefile->GetIncludeDirectoriesEntries());
-    cm::append(impl->IncludeDirectoriesBacktraces,
-               impl->Makefile->GetIncludeDirectoriesBacktraces());
+    cm::append(this->impl->IncludeDirectoriesEntries,
+               this->impl->Makefile->GetIncludeDirectoriesEntries());
+    cm::append(this->impl->IncludeDirectoriesBacktraces,
+               this->impl->Makefile->GetIncludeDirectoriesBacktraces());
 
     {
-      auto const& sysInc = impl->Makefile->GetSystemIncludeDirectories();
-      impl->SystemIncludeDirectories.insert(sysInc.begin(), sysInc.end());
+      auto const& sysInc = this->impl->Makefile->GetSystemIncludeDirectories();
+      this->impl->SystemIncludeDirectories.insert(sysInc.begin(),
+                                                  sysInc.end());
     }
 
-    cm::append(impl->CompileOptionsEntries,
-               impl->Makefile->GetCompileOptionsEntries());
-    cm::append(impl->CompileOptionsBacktraces,
-               impl->Makefile->GetCompileOptionsBacktraces());
+    cm::append(this->impl->CompileOptionsEntries,
+               this->impl->Makefile->GetCompileOptionsEntries());
+    cm::append(this->impl->CompileOptionsBacktraces,
+               this->impl->Makefile->GetCompileOptionsBacktraces());
 
-    cm::append(impl->LinkOptionsEntries,
-               impl->Makefile->GetLinkOptionsEntries());
-    cm::append(impl->LinkOptionsBacktraces,
-               impl->Makefile->GetLinkOptionsBacktraces());
+    cm::append(this->impl->LinkOptionsEntries,
+               this->impl->Makefile->GetLinkOptionsEntries());
+    cm::append(this->impl->LinkOptionsBacktraces,
+               this->impl->Makefile->GetLinkOptionsBacktraces());
 
-    cm::append(impl->LinkDirectoriesEntries,
-               impl->Makefile->GetLinkDirectoriesEntries());
-    cm::append(impl->LinkDirectoriesBacktraces,
-               impl->Makefile->GetLinkDirectoriesBacktraces());
+    cm::append(this->impl->LinkDirectoriesEntries,
+               this->impl->Makefile->GetLinkDirectoriesEntries());
+    cm::append(this->impl->LinkDirectoriesBacktraces,
+               this->impl->Makefile->GetLinkDirectoriesBacktraces());
   }
 
-  if (impl->TargetType == cmStateEnums::EXECUTABLE) {
+  if (this->impl->TargetType == cmStateEnums::EXECUTABLE) {
     initProp("ANDROID_GUI");
     initProp("CROSSCOMPILING_EMULATOR");
     initProp("ENABLE_EXPORTS");
   }
-  if (impl->TargetType == cmStateEnums::SHARED_LIBRARY ||
-      impl->TargetType == cmStateEnums::MODULE_LIBRARY) {
+  if (this->impl->TargetType == cmStateEnums::SHARED_LIBRARY ||
+      this->impl->TargetType == cmStateEnums::MODULE_LIBRARY) {
     this->SetProperty("POSITION_INDEPENDENT_CODE", "True");
   } else if (this->CanCompileSources()) {
     initProp("POSITION_INDEPENDENT_CODE");
   }
-  if (impl->TargetType == cmStateEnums::SHARED_LIBRARY ||
-      impl->TargetType == cmStateEnums::EXECUTABLE) {
+  if (this->impl->TargetType == cmStateEnums::SHARED_LIBRARY ||
+      this->impl->TargetType == cmStateEnums::EXECUTABLE) {
     initProp("AIX_EXPORT_ALL_SYMBOLS");
     initProp("WINDOWS_EXPORT_ALL_SYMBOLS");
   }
 
   // Record current policies for later use.
-  impl->Makefile->RecordPolicies(impl->PolicyMap);
+  this->impl->Makefile->RecordPolicies(this->impl->PolicyMap);
 
-  if (impl->TargetType == cmStateEnums::INTERFACE_LIBRARY) {
+  if (this->impl->TargetType == cmStateEnums::INTERFACE_LIBRARY) {
     // This policy is checked in a few conditions. The properties relevant
     // to the policy are always ignored for cmStateEnums::INTERFACE_LIBRARY
     // targets,
     // so ensure that the conditions don't lead to nonsense.
-    impl->PolicyMap.Set(cmPolicies::CMP0022, cmPolicies::NEW);
+    this->impl->PolicyMap.Set(cmPolicies::CMP0022, cmPolicies::NEW);
   }
 
-  if (impl->TargetType <= cmStateEnums::GLOBAL_TARGET) {
+  if (this->impl->TargetType <= cmStateEnums::GLOBAL_TARGET) {
     initProp("DOTNET_TARGET_FRAMEWORK");
     initProp("DOTNET_TARGET_FRAMEWORK_VERSION");
   }
@@ -558,40 +560,40 @@ cmTarget& cmTarget::operator=(cmTarget&&) noexcept = default;
 
 cmStateEnums::TargetType cmTarget::GetType() const
 {
-  return impl->TargetType;
+  return this->impl->TargetType;
 }
 
 cmMakefile* cmTarget::GetMakefile() const
 {
-  return impl->Makefile;
+  return this->impl->Makefile;
 }
 
 cmPolicies::PolicyMap const& cmTarget::GetPolicyMap() const
 {
-  return impl->PolicyMap;
+  return this->impl->PolicyMap;
 }
 
 const std::string& cmTarget::GetName() const
 {
-  return impl->Name;
+  return this->impl->Name;
 }
 
 cmPolicies::PolicyStatus cmTarget::GetPolicyStatus(
   cmPolicies::PolicyID policy) const
 {
-  return impl->PolicyMap.Get(policy);
+  return this->impl->PolicyMap.Get(policy);
 }
 
 cmGlobalGenerator* cmTarget::GetGlobalGenerator() const
 {
-  return impl->Makefile->GetGlobalGenerator();
+  return this->impl->Makefile->GetGlobalGenerator();
 }
 
 BTs<std::string> const* cmTarget::GetLanguageStandardProperty(
   const std::string& propertyName) const
 {
-  auto entry = impl->LanguageStandardProperties.find(propertyName);
-  if (entry != impl->LanguageStandardProperties.end()) {
+  auto entry = this->impl->LanguageStandardProperties.find(propertyName);
+  if (entry != this->impl->LanguageStandardProperties.end()) {
     return &entry->second;
   }
 
@@ -603,17 +605,17 @@ void cmTarget::SetLanguageStandardProperty(std::string const& lang,
                                            const std::string& feature)
 {
   cmListFileBacktrace featureBacktrace;
-  for (size_t i = 0; i < impl->CompileFeaturesEntries.size(); i++) {
-    if (impl->CompileFeaturesEntries[i] == feature) {
-      if (i < impl->CompileFeaturesBacktraces.size()) {
-        featureBacktrace = impl->CompileFeaturesBacktraces[i];
+  for (size_t i = 0; i < this->impl->CompileFeaturesEntries.size(); i++) {
+    if (this->impl->CompileFeaturesEntries[i] == feature) {
+      if (i < this->impl->CompileFeaturesBacktraces.size()) {
+        featureBacktrace = this->impl->CompileFeaturesBacktraces[i];
       }
       break;
     }
   }
 
   BTs<std::string>& languageStandardProperty =
-    impl->LanguageStandardProperties[cmStrCat(lang, "_STANDARD")];
+    this->impl->LanguageStandardProperties[cmStrCat(lang, "_STANDARD")];
   if (languageStandardProperty.Value != value) {
     languageStandardProperty.Value = value;
     languageStandardProperty.Backtraces.clear();
@@ -623,24 +625,24 @@ void cmTarget::SetLanguageStandardProperty(std::string const& lang,
 
 void cmTarget::AddUtility(std::string const& name, bool cross, cmMakefile* mf)
 {
-  impl->Utilities.insert(BT<std::pair<std::string, bool>>(
+  this->impl->Utilities.insert(BT<std::pair<std::string, bool>>(
     { name, cross }, mf ? mf->GetBacktrace() : cmListFileBacktrace()));
 }
 
 void cmTarget::AddUtility(BT<std::pair<std::string, bool>> util)
 {
-  impl->Utilities.emplace(std::move(util));
+  this->impl->Utilities.emplace(std::move(util));
 }
 
 std::set<BT<std::pair<std::string, bool>>> const& cmTarget::GetUtilities()
   const
 {
-  return impl->Utilities;
+  return this->impl->Utilities;
 }
 
 cmListFileBacktrace const& cmTarget::GetBacktrace() const
 {
-  return impl->Backtrace;
+  return this->impl->Backtrace;
 }
 
 bool cmTarget::IsExecutableWithExports() const
@@ -653,74 +655,74 @@ bool cmTarget::IsFrameworkOnApple() const
 {
   return ((this->GetType() == cmStateEnums::SHARED_LIBRARY ||
            this->GetType() == cmStateEnums::STATIC_LIBRARY) &&
-          impl->Makefile->IsOn("APPLE") &&
+          this->impl->Makefile->IsOn("APPLE") &&
           this->GetPropertyAsBool("FRAMEWORK"));
 }
 
 bool cmTarget::IsAppBundleOnApple() const
 {
   return (this->GetType() == cmStateEnums::EXECUTABLE &&
-          impl->Makefile->IsOn("APPLE") &&
+          this->impl->Makefile->IsOn("APPLE") &&
           this->GetPropertyAsBool("MACOSX_BUNDLE"));
 }
 
 bool cmTarget::IsAndroidGuiExecutable() const
 {
-  return (this->GetType() == cmStateEnums::EXECUTABLE && impl->IsAndroid &&
-          this->GetPropertyAsBool("ANDROID_GUI"));
+  return (this->GetType() == cmStateEnums::EXECUTABLE &&
+          this->impl->IsAndroid && this->GetPropertyAsBool("ANDROID_GUI"));
 }
 
 std::vector<cmCustomCommand> const& cmTarget::GetPreBuildCommands() const
 {
-  return impl->PreBuildCommands;
+  return this->impl->PreBuildCommands;
 }
 
 void cmTarget::AddPreBuildCommand(cmCustomCommand const& cmd)
 {
-  impl->PreBuildCommands.push_back(cmd);
+  this->impl->PreBuildCommands.push_back(cmd);
 }
 
 void cmTarget::AddPreBuildCommand(cmCustomCommand&& cmd)
 {
-  impl->PreBuildCommands.push_back(std::move(cmd));
+  this->impl->PreBuildCommands.push_back(std::move(cmd));
 }
 
 std::vector<cmCustomCommand> const& cmTarget::GetPreLinkCommands() const
 {
-  return impl->PreLinkCommands;
+  return this->impl->PreLinkCommands;
 }
 
 void cmTarget::AddPreLinkCommand(cmCustomCommand const& cmd)
 {
-  impl->PreLinkCommands.push_back(cmd);
+  this->impl->PreLinkCommands.push_back(cmd);
 }
 
 void cmTarget::AddPreLinkCommand(cmCustomCommand&& cmd)
 {
-  impl->PreLinkCommands.push_back(std::move(cmd));
+  this->impl->PreLinkCommands.push_back(std::move(cmd));
 }
 
 std::vector<cmCustomCommand> const& cmTarget::GetPostBuildCommands() const
 {
-  return impl->PostBuildCommands;
+  return this->impl->PostBuildCommands;
 }
 
 void cmTarget::AddPostBuildCommand(cmCustomCommand const& cmd)
 {
-  impl->PostBuildCommands.push_back(cmd);
+  this->impl->PostBuildCommands.push_back(cmd);
 }
 
 void cmTarget::AddPostBuildCommand(cmCustomCommand&& cmd)
 {
-  impl->PostBuildCommands.push_back(std::move(cmd));
+  this->impl->PostBuildCommands.push_back(std::move(cmd));
 }
 
 void cmTarget::AddTracedSources(std::vector<std::string> const& srcs)
 {
   if (!srcs.empty()) {
-    cmListFileBacktrace lfbt = impl->Makefile->GetBacktrace();
-    impl->SourceEntries.push_back(cmJoin(srcs, ";"));
-    impl->SourceBacktraces.push_back(lfbt);
+    cmListFileBacktrace lfbt = this->impl->Makefile->GetBacktrace();
+    this->impl->SourceEntries.push_back(cmJoin(srcs, ";"));
+    this->impl->SourceBacktraces.push_back(lfbt);
   }
 }
 
@@ -731,21 +733,21 @@ void cmTarget::AddSources(std::vector<std::string> const& srcs)
   for (auto filename : srcs) {
     if (!cmGeneratorExpression::StartsWithGeneratorExpression(filename)) {
       if (!filename.empty()) {
-        filename = impl->ProcessSourceItemCMP0049(filename);
+        filename = this->impl->ProcessSourceItemCMP0049(filename);
         if (filename.empty()) {
           return;
         }
       }
-      impl->Makefile->GetOrCreateSource(filename);
+      this->impl->Makefile->GetOrCreateSource(filename);
     }
     srcFiles += sep;
     srcFiles += filename;
     sep = ";";
   }
   if (!srcFiles.empty()) {
-    cmListFileBacktrace lfbt = impl->Makefile->GetBacktrace();
-    impl->SourceEntries.push_back(std::move(srcFiles));
-    impl->SourceBacktraces.push_back(lfbt);
+    cmListFileBacktrace lfbt = this->impl->Makefile->GetBacktrace();
+    this->impl->SourceEntries.push_back(std::move(srcFiles));
+    this->impl->SourceBacktraces.push_back(lfbt);
   }
 }
 
@@ -789,7 +791,7 @@ std::string cmTargetInternals::ProcessSourceItemCMP0049(
 
 std::string cmTarget::GetSourceCMP0049(const std::string& s)
 {
-  return impl->ProcessSourceItemCMP0049(s);
+  return this->impl->ProcessSourceItemCMP0049(s);
 }
 
 struct CreateLocation
@@ -848,23 +850,25 @@ public:
 
 cmSourceFile* cmTarget::AddSource(const std::string& src, bool before)
 {
-  cmSourceFileLocation sfl(impl->Makefile, src,
+  cmSourceFileLocation sfl(this->impl->Makefile, src,
                            cmSourceFileLocationKind::Known);
-  if (std::find_if(impl->SourceEntries.begin(), impl->SourceEntries.end(),
-                   TargetPropertyEntryFinder(sfl)) ==
-      impl->SourceEntries.end()) {
-    cmListFileBacktrace lfbt = impl->Makefile->GetBacktrace();
-    impl->SourceEntries.insert(
-      before ? impl->SourceEntries.begin() : impl->SourceEntries.end(), src);
-    impl->SourceBacktraces.insert(before ? impl->SourceBacktraces.begin()
-                                         : impl->SourceBacktraces.end(),
-                                  lfbt);
+  if (std::find_if(
+        this->impl->SourceEntries.begin(), this->impl->SourceEntries.end(),
+        TargetPropertyEntryFinder(sfl)) == this->impl->SourceEntries.end()) {
+    cmListFileBacktrace lfbt = this->impl->Makefile->GetBacktrace();
+    this->impl->SourceEntries.insert(before ? this->impl->SourceEntries.begin()
+                                            : this->impl->SourceEntries.end(),
+                                     src);
+    this->impl->SourceBacktraces.insert(
+      before ? this->impl->SourceBacktraces.begin()
+             : this->impl->SourceBacktraces.end(),
+      lfbt);
   }
   if (cmGeneratorExpression::Find(src) != std::string::npos) {
     return nullptr;
   }
-  return impl->Makefile->GetOrCreateSource(src, false,
-                                           cmSourceFileLocationKind::Known);
+  return this->impl->Makefile->GetOrCreateSource(
+    src, false, cmSourceFileLocationKind::Known);
 }
 
 void cmTarget::ClearDependencyInformation(cmMakefile& mf) const
@@ -882,7 +886,7 @@ std::string cmTarget::GetDebugGeneratorExpressions(
 
   // Get the list of configurations considered to be DEBUG.
   std::vector<std::string> debugConfigs =
-    impl->Makefile->GetCMakeInstance()->GetDebugConfigs();
+    this->impl->Makefile->GetCMakeInstance()->GetDebugConfigs();
 
   std::string configString = "$<CONFIG:" + debugConfigs[0] + ">";
 
@@ -908,13 +912,14 @@ bool cmTarget::PushTLLCommandTrace(TLLSignature signature,
                                    cmListFileContext const& lfc)
 {
   bool ret = true;
-  if (!impl->TLLCommands.empty()) {
-    if (impl->TLLCommands.back().first != signature) {
+  if (!this->impl->TLLCommands.empty()) {
+    if (this->impl->TLLCommands.back().first != signature) {
       ret = false;
     }
   }
-  if (impl->TLLCommands.empty() || impl->TLLCommands.back().second != lfc) {
-    impl->TLLCommands.emplace_back(signature, lfc);
+  if (this->impl->TLLCommands.empty() ||
+      this->impl->TLLCommands.back().second != lfc) {
+    this->impl->TLLCommands.emplace_back(signature, lfc);
   }
   return ret;
 }
@@ -924,12 +929,13 @@ void cmTarget::GetTllSignatureTraces(std::ostream& s, TLLSignature sig) const
   const char* sigString =
     (sig == cmTarget::KeywordTLLSignature ? "keyword" : "plain");
   s << "The uses of the " << sigString << " signature are here:\n";
-  cmStateDirectory cmDir = impl->Makefile->GetStateSnapshot().GetDirectory();
-  for (auto const& cmd : impl->TLLCommands) {
+  cmStateDirectory cmDir =
+    this->impl->Makefile->GetStateSnapshot().GetDirectory();
+  for (auto const& cmd : this->impl->TLLCommands) {
     if (cmd.first == sig) {
       cmListFileContext lfc = cmd.second;
       lfc.FilePath = cmDir.ConvertToRelPathIfNotContained(
-        impl->Makefile->GetState()->GetSourceDirectory(), lfc.FilePath);
+        this->impl->Makefile->GetState()->GetSourceDirectory(), lfc.FilePath);
       s << " * " << lfc << '\n';
     }
   }
@@ -937,59 +943,59 @@ void cmTarget::GetTllSignatureTraces(std::ostream& s, TLLSignature sig) const
 
 std::string const& cmTarget::GetInstallPath() const
 {
-  return impl->InstallPath;
+  return this->impl->InstallPath;
 }
 
 void cmTarget::SetInstallPath(std::string const& name)
 {
-  impl->InstallPath = name;
+  this->impl->InstallPath = name;
 }
 
 std::string const& cmTarget::GetRuntimeInstallPath() const
 {
-  return impl->RuntimeInstallPath;
+  return this->impl->RuntimeInstallPath;
 }
 
 void cmTarget::SetRuntimeInstallPath(std::string const& name)
 {
-  impl->RuntimeInstallPath = name;
+  this->impl->RuntimeInstallPath = name;
 }
 
 bool cmTarget::GetHaveInstallRule() const
 {
-  return impl->HaveInstallRule;
+  return this->impl->HaveInstallRule;
 }
 
 void cmTarget::SetHaveInstallRule(bool hir)
 {
-  impl->HaveInstallRule = hir;
+  this->impl->HaveInstallRule = hir;
 }
 
 void cmTarget::AddInstallGenerator(cmInstallTargetGenerator* g)
 {
-  impl->InstallGenerators.emplace_back(g);
+  this->impl->InstallGenerators.emplace_back(g);
 }
 
 std::vector<cmInstallTargetGenerator*> const& cmTarget::GetInstallGenerators()
   const
 {
-  return impl->InstallGenerators;
+  return this->impl->InstallGenerators;
 }
 
 bool cmTarget::GetIsGeneratorProvided() const
 {
-  return impl->IsGeneratorProvided;
+  return this->impl->IsGeneratorProvided;
 }
 
 void cmTarget::SetIsGeneratorProvided(bool igp)
 {
-  impl->IsGeneratorProvided = igp;
+  this->impl->IsGeneratorProvided = igp;
 }
 
 cmTarget::LinkLibraryVectorType const& cmTarget::GetOriginalLinkLibraries()
   const
 {
-  return impl->OriginalLinkLibraries;
+  return this->impl->OriginalLinkLibraries;
 }
 
 void cmTarget::AddLinkLibrary(cmMakefile& mf, std::string const& lib,
@@ -1011,11 +1017,11 @@ void cmTarget::AddLinkLibrary(cmMakefile& mf, std::string const& lib,
       (tgt &&
        (tgt->GetType() == cmStateEnums::INTERFACE_LIBRARY ||
         tgt->GetType() == cmStateEnums::OBJECT_LIBRARY)) ||
-      (impl->Name == lib)) {
+      (this->impl->Name == lib)) {
     return;
   }
 
-  impl->OriginalLinkLibraries.emplace_back(lib, llt);
+  this->impl->OriginalLinkLibraries.emplace_back(lib, llt);
 
   // Add the explicit dependency information for libraries. This is
   // simply a set of libraries separated by ";". There should always
@@ -1025,11 +1031,11 @@ void cmTarget::AddLinkLibrary(cmMakefile& mf, std::string const& 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 (impl->TargetType >= cmStateEnums::STATIC_LIBRARY &&
-      impl->TargetType <= cmStateEnums::MODULE_LIBRARY &&
+  if (this->impl->TargetType >= cmStateEnums::STATIC_LIBRARY &&
+      this->impl->TargetType <= cmStateEnums::MODULE_LIBRARY &&
       (this->GetPolicyStatusCMP0073() == cmPolicies::OLD ||
        this->GetPolicyStatusCMP0073() == cmPolicies::WARN)) {
-    std::string targetEntry = cmStrCat(impl->Name, "_LIB_DEPENDS");
+    std::string targetEntry = cmStrCat(this->impl->Name, "_LIB_DEPENDS");
     std::string dependencies;
     cmProp old_val = mf.GetDefinition(targetEntry);
     if (old_val) {
@@ -1056,102 +1062,102 @@ void cmTarget::AddLinkLibrary(cmMakefile& mf, std::string const& lib,
 
 void cmTarget::AddSystemIncludeDirectories(const std::set<std::string>& incs)
 {
-  impl->SystemIncludeDirectories.insert(incs.begin(), incs.end());
+  this->impl->SystemIncludeDirectories.insert(incs.begin(), incs.end());
 }
 
 std::set<std::string> const& cmTarget::GetSystemIncludeDirectories() const
 {
-  return impl->SystemIncludeDirectories;
+  return this->impl->SystemIncludeDirectories;
 }
 
 cmStringRange cmTarget::GetIncludeDirectoriesEntries() const
 {
-  return cmMakeRange(impl->IncludeDirectoriesEntries);
+  return cmMakeRange(this->impl->IncludeDirectoriesEntries);
 }
 
 cmBacktraceRange cmTarget::GetIncludeDirectoriesBacktraces() const
 {
-  return cmMakeRange(impl->IncludeDirectoriesBacktraces);
+  return cmMakeRange(this->impl->IncludeDirectoriesBacktraces);
 }
 
 cmStringRange cmTarget::GetCompileOptionsEntries() const
 {
-  return cmMakeRange(impl->CompileOptionsEntries);
+  return cmMakeRange(this->impl->CompileOptionsEntries);
 }
 
 cmBacktraceRange cmTarget::GetCompileOptionsBacktraces() const
 {
-  return cmMakeRange(impl->CompileOptionsBacktraces);
+  return cmMakeRange(this->impl->CompileOptionsBacktraces);
 }
 
 cmStringRange cmTarget::GetCompileFeaturesEntries() const
 {
-  return cmMakeRange(impl->CompileFeaturesEntries);
+  return cmMakeRange(this->impl->CompileFeaturesEntries);
 }
 
 cmBacktraceRange cmTarget::GetCompileFeaturesBacktraces() const
 {
-  return cmMakeRange(impl->CompileFeaturesBacktraces);
+  return cmMakeRange(this->impl->CompileFeaturesBacktraces);
 }
 
 cmStringRange cmTarget::GetCompileDefinitionsEntries() const
 {
-  return cmMakeRange(impl->CompileDefinitionsEntries);
+  return cmMakeRange(this->impl->CompileDefinitionsEntries);
 }
 
 cmBacktraceRange cmTarget::GetCompileDefinitionsBacktraces() const
 {
-  return cmMakeRange(impl->CompileDefinitionsBacktraces);
+  return cmMakeRange(this->impl->CompileDefinitionsBacktraces);
 }
 
 cmStringRange cmTarget::GetPrecompileHeadersEntries() const
 {
-  return cmMakeRange(impl->PrecompileHeadersEntries);
+  return cmMakeRange(this->impl->PrecompileHeadersEntries);
 }
 
 cmBacktraceRange cmTarget::GetPrecompileHeadersBacktraces() const
 {
-  return cmMakeRange(impl->PrecompileHeadersBacktraces);
+  return cmMakeRange(this->impl->PrecompileHeadersBacktraces);
 }
 
 cmStringRange cmTarget::GetSourceEntries() const
 {
-  return cmMakeRange(impl->SourceEntries);
+  return cmMakeRange(this->impl->SourceEntries);
 }
 
 cmBacktraceRange cmTarget::GetSourceBacktraces() const
 {
-  return cmMakeRange(impl->SourceBacktraces);
+  return cmMakeRange(this->impl->SourceBacktraces);
 }
 
 cmStringRange cmTarget::GetLinkOptionsEntries() const
 {
-  return cmMakeRange(impl->LinkOptionsEntries);
+  return cmMakeRange(this->impl->LinkOptionsEntries);
 }
 
 cmBacktraceRange cmTarget::GetLinkOptionsBacktraces() const
 {
-  return cmMakeRange(impl->LinkOptionsBacktraces);
+  return cmMakeRange(this->impl->LinkOptionsBacktraces);
 }
 
 cmStringRange cmTarget::GetLinkDirectoriesEntries() const
 {
-  return cmMakeRange(impl->LinkDirectoriesEntries);
+  return cmMakeRange(this->impl->LinkDirectoriesEntries);
 }
 
 cmBacktraceRange cmTarget::GetLinkDirectoriesBacktraces() const
 {
-  return cmMakeRange(impl->LinkDirectoriesBacktraces);
+  return cmMakeRange(this->impl->LinkDirectoriesBacktraces);
 }
 
 cmStringRange cmTarget::GetLinkImplementationEntries() const
 {
-  return cmMakeRange(impl->LinkImplementationPropertyEntries);
+  return cmMakeRange(this->impl->LinkImplementationPropertyEntries);
 }
 
 cmBacktraceRange cmTarget::GetLinkImplementationBacktraces() const
 {
-  return cmMakeRange(impl->LinkImplementationPropertyBacktraces);
+  return cmMakeRange(this->impl->LinkImplementationPropertyBacktraces);
 }
 
 void cmTarget::SetProperty(const std::string& prop, const char* value)
@@ -1180,154 +1186,154 @@ void cmTarget::SetProperty(const std::string& prop, const char* value)
   MAKE_STATIC_PROP(TYPE);
 #undef MAKE_STATIC_PROP
   if (prop == propMANUALLY_ADDED_DEPENDENCIES) {
-    impl->Makefile->IssueMessage(
+    this->impl->Makefile->IssueMessage(
       MessageType::FATAL_ERROR,
       "MANUALLY_ADDED_DEPENDENCIES property is read-only\n");
     return;
   }
   if (prop == propNAME) {
-    impl->Makefile->IssueMessage(MessageType::FATAL_ERROR,
-                                 "NAME property is read-only\n");
+    this->impl->Makefile->IssueMessage(MessageType::FATAL_ERROR,
+                                       "NAME property is read-only\n");
     return;
   }
   if (prop == propTYPE) {
-    impl->Makefile->IssueMessage(MessageType::FATAL_ERROR,
-                                 "TYPE property is read-only\n");
+    this->impl->Makefile->IssueMessage(MessageType::FATAL_ERROR,
+                                       "TYPE property is read-only\n");
     return;
   }
   if (prop == propEXPORT_NAME && this->IsImported()) {
     std::ostringstream e;
     e << "EXPORT_NAME property can't be set on imported targets (\""
-      << impl->Name << "\")\n";
-    impl->Makefile->IssueMessage(MessageType::FATAL_ERROR, e.str());
+      << this->impl->Name << "\")\n";
+    this->impl->Makefile->IssueMessage(MessageType::FATAL_ERROR, e.str());
     return;
   }
   if (prop == propSOURCES && this->IsImported()) {
     std::ostringstream e;
-    e << "SOURCES property can't be set on imported targets (\"" << impl->Name
-      << "\")\n";
-    impl->Makefile->IssueMessage(MessageType::FATAL_ERROR, e.str());
+    e << "SOURCES property can't be set on imported targets (\""
+      << this->impl->Name << "\")\n";
+    this->impl->Makefile->IssueMessage(MessageType::FATAL_ERROR, e.str());
     return;
   }
   if (prop == propIMPORTED_GLOBAL && !this->IsImported()) {
     std::ostringstream e;
     e << "IMPORTED_GLOBAL property can't be set on non-imported targets (\""
-      << impl->Name << "\")\n";
-    impl->Makefile->IssueMessage(MessageType::FATAL_ERROR, e.str());
+      << this->impl->Name << "\")\n";
+    this->impl->Makefile->IssueMessage(MessageType::FATAL_ERROR, e.str());
     return;
   }
 
   if (prop == propINCLUDE_DIRECTORIES) {
-    impl->IncludeDirectoriesEntries.clear();
-    impl->IncludeDirectoriesBacktraces.clear();
+    this->impl->IncludeDirectoriesEntries.clear();
+    this->impl->IncludeDirectoriesBacktraces.clear();
     if (value) {
-      impl->IncludeDirectoriesEntries.emplace_back(value);
-      cmListFileBacktrace lfbt = impl->Makefile->GetBacktrace();
-      impl->IncludeDirectoriesBacktraces.push_back(lfbt);
+      this->impl->IncludeDirectoriesEntries.emplace_back(value);
+      cmListFileBacktrace lfbt = this->impl->Makefile->GetBacktrace();
+      this->impl->IncludeDirectoriesBacktraces.push_back(lfbt);
     }
   } else if (prop == propCOMPILE_OPTIONS) {
-    impl->CompileOptionsEntries.clear();
-    impl->CompileOptionsBacktraces.clear();
+    this->impl->CompileOptionsEntries.clear();
+    this->impl->CompileOptionsBacktraces.clear();
     if (value) {
-      impl->CompileOptionsEntries.emplace_back(value);
-      cmListFileBacktrace lfbt = impl->Makefile->GetBacktrace();
-      impl->CompileOptionsBacktraces.push_back(lfbt);
+      this->impl->CompileOptionsEntries.emplace_back(value);
+      cmListFileBacktrace lfbt = this->impl->Makefile->GetBacktrace();
+      this->impl->CompileOptionsBacktraces.push_back(lfbt);
     }
   } else if (prop == propCOMPILE_FEATURES) {
-    impl->CompileFeaturesEntries.clear();
-    impl->CompileFeaturesBacktraces.clear();
+    this->impl->CompileFeaturesEntries.clear();
+    this->impl->CompileFeaturesBacktraces.clear();
     if (value) {
-      impl->CompileFeaturesEntries.emplace_back(value);
-      cmListFileBacktrace lfbt = impl->Makefile->GetBacktrace();
-      impl->CompileFeaturesBacktraces.push_back(lfbt);
+      this->impl->CompileFeaturesEntries.emplace_back(value);
+      cmListFileBacktrace lfbt = this->impl->Makefile->GetBacktrace();
+      this->impl->CompileFeaturesBacktraces.push_back(lfbt);
     }
   } else if (prop == propCOMPILE_DEFINITIONS) {
-    impl->CompileDefinitionsEntries.clear();
-    impl->CompileDefinitionsBacktraces.clear();
+    this->impl->CompileDefinitionsEntries.clear();
+    this->impl->CompileDefinitionsBacktraces.clear();
     if (value) {
-      impl->CompileDefinitionsEntries.emplace_back(value);
-      cmListFileBacktrace lfbt = impl->Makefile->GetBacktrace();
-      impl->CompileDefinitionsBacktraces.push_back(lfbt);
+      this->impl->CompileDefinitionsEntries.emplace_back(value);
+      cmListFileBacktrace lfbt = this->impl->Makefile->GetBacktrace();
+      this->impl->CompileDefinitionsBacktraces.push_back(lfbt);
     }
   } else if (prop == propLINK_OPTIONS) {
-    impl->LinkOptionsEntries.clear();
-    impl->LinkOptionsBacktraces.clear();
+    this->impl->LinkOptionsEntries.clear();
+    this->impl->LinkOptionsBacktraces.clear();
     if (value) {
-      impl->LinkOptionsEntries.emplace_back(value);
-      cmListFileBacktrace lfbt = impl->Makefile->GetBacktrace();
-      impl->LinkOptionsBacktraces.push_back(lfbt);
+      this->impl->LinkOptionsEntries.emplace_back(value);
+      cmListFileBacktrace lfbt = this->impl->Makefile->GetBacktrace();
+      this->impl->LinkOptionsBacktraces.push_back(lfbt);
     }
   } else if (prop == propLINK_DIRECTORIES) {
-    impl->LinkDirectoriesEntries.clear();
-    impl->LinkDirectoriesBacktraces.clear();
+    this->impl->LinkDirectoriesEntries.clear();
+    this->impl->LinkDirectoriesBacktraces.clear();
     if (value) {
-      impl->LinkDirectoriesEntries.emplace_back(value);
-      cmListFileBacktrace lfbt = impl->Makefile->GetBacktrace();
-      impl->LinkDirectoriesBacktraces.push_back(lfbt);
+      this->impl->LinkDirectoriesEntries.emplace_back(value);
+      cmListFileBacktrace lfbt = this->impl->Makefile->GetBacktrace();
+      this->impl->LinkDirectoriesBacktraces.push_back(lfbt);
     }
   } else if (prop == propPRECOMPILE_HEADERS) {
-    impl->PrecompileHeadersEntries.clear();
-    impl->PrecompileHeadersBacktraces.clear();
+    this->impl->PrecompileHeadersEntries.clear();
+    this->impl->PrecompileHeadersBacktraces.clear();
     if (value) {
-      impl->PrecompileHeadersEntries.emplace_back(value);
-      cmListFileBacktrace lfbt = impl->Makefile->GetBacktrace();
-      impl->PrecompileHeadersBacktraces.push_back(lfbt);
+      this->impl->PrecompileHeadersEntries.emplace_back(value);
+      cmListFileBacktrace lfbt = this->impl->Makefile->GetBacktrace();
+      this->impl->PrecompileHeadersBacktraces.push_back(lfbt);
     }
   } else if (prop == propLINK_LIBRARIES) {
-    impl->LinkImplementationPropertyEntries.clear();
-    impl->LinkImplementationPropertyBacktraces.clear();
+    this->impl->LinkImplementationPropertyEntries.clear();
+    this->impl->LinkImplementationPropertyBacktraces.clear();
     if (value) {
-      cmListFileBacktrace lfbt = impl->Makefile->GetBacktrace();
-      impl->LinkImplementationPropertyEntries.emplace_back(value);
-      impl->LinkImplementationPropertyBacktraces.push_back(lfbt);
+      cmListFileBacktrace lfbt = this->impl->Makefile->GetBacktrace();
+      this->impl->LinkImplementationPropertyEntries.emplace_back(value);
+      this->impl->LinkImplementationPropertyBacktraces.push_back(lfbt);
     }
   } else if (prop == propSOURCES) {
-    impl->SourceEntries.clear();
-    impl->SourceBacktraces.clear();
+    this->impl->SourceEntries.clear();
+    this->impl->SourceBacktraces.clear();
     if (value) {
-      cmListFileBacktrace lfbt = impl->Makefile->GetBacktrace();
-      impl->SourceEntries.emplace_back(value);
-      impl->SourceBacktraces.push_back(lfbt);
+      cmListFileBacktrace lfbt = this->impl->Makefile->GetBacktrace();
+      this->impl->SourceEntries.emplace_back(value);
+      this->impl->SourceBacktraces.push_back(lfbt);
     }
   } else if (prop == propIMPORTED_GLOBAL) {
     if (!cmIsOn(value)) {
       std::ostringstream e;
       e << "IMPORTED_GLOBAL property can't be set to FALSE on targets (\""
-        << impl->Name << "\")\n";
-      impl->Makefile->IssueMessage(MessageType::FATAL_ERROR, e.str());
+        << this->impl->Name << "\")\n";
+      this->impl->Makefile->IssueMessage(MessageType::FATAL_ERROR, e.str());
       return;
     }
     /* no need to change anything if value does not change */
-    if (!impl->ImportedGloballyVisible) {
-      impl->ImportedGloballyVisible = true;
+    if (!this->impl->ImportedGloballyVisible) {
+      this->impl->ImportedGloballyVisible = true;
       this->GetGlobalGenerator()->IndexTarget(this);
     }
   } else if (cmHasLiteralPrefix(prop, "IMPORTED_LIBNAME") &&
-             !impl->CheckImportedLibName(prop, value ? value : "")) {
+             !this->impl->CheckImportedLibName(prop, value ? value : "")) {
     /* error was reported by check method */
   } else if (prop == propCUDA_PTX_COMPILATION &&
              this->GetType() != cmStateEnums::OBJECT_LIBRARY) {
     std::ostringstream e;
     e << "CUDA_PTX_COMPILATION property can only be applied to OBJECT "
          "targets (\""
-      << impl->Name << "\")\n";
-    impl->Makefile->IssueMessage(MessageType::FATAL_ERROR, e.str());
+      << this->impl->Name << "\")\n";
+    this->impl->Makefile->IssueMessage(MessageType::FATAL_ERROR, e.str());
     return;
   } else if (prop == propPRECOMPILE_HEADERS_REUSE_FROM) {
     if (this->GetProperty("PRECOMPILE_HEADERS")) {
       std::ostringstream e;
       e << "PRECOMPILE_HEADERS property is already set on target (\""
-        << impl->Name << "\")\n";
-      impl->Makefile->IssueMessage(MessageType::FATAL_ERROR, e.str());
+        << this->impl->Name << "\")\n";
+      this->impl->Makefile->IssueMessage(MessageType::FATAL_ERROR, e.str());
       return;
     }
-    auto reusedTarget =
-      impl->Makefile->GetCMakeInstance()->GetGlobalGenerator()->FindTarget(
-        value);
+    auto reusedTarget = this->impl->Makefile->GetCMakeInstance()
+                          ->GetGlobalGenerator()
+                          ->FindTarget(value);
     if (!reusedTarget) {
       const std::string e(
         "PRECOMPILE_HEADERS_REUSE_FROM set with non existing target");
-      impl->Makefile->IssueMessage(MessageType::FATAL_ERROR, e);
+      this->impl->Makefile->IssueMessage(MessageType::FATAL_ERROR, e);
       return;
     }
 
@@ -1336,7 +1342,7 @@ void cmTarget::SetProperty(const std::string& prop, const char* value)
       reusedFrom = value;
     }
 
-    impl->Properties.SetProperty(prop, reusedFrom.c_str());
+    this->impl->Properties.SetProperty(prop, reusedFrom.c_str());
 
     reusedTarget->SetProperty("COMPILE_PDB_NAME", reusedFrom);
     reusedTarget->SetProperty("COMPILE_PDB_OUTPUT_DIRECTORY",
@@ -1344,18 +1350,18 @@ void cmTarget::SetProperty(const std::string& prop, const char* value)
 
     cmProp tmp = reusedTarget->GetProperty("COMPILE_PDB_NAME");
     this->SetProperty("COMPILE_PDB_NAME", cmToCStr(tmp));
-    this->AddUtility(reusedFrom, false, impl->Makefile);
+    this->AddUtility(reusedFrom, false, this->impl->Makefile);
   } else if (prop == propC_STANDARD || prop == propCXX_STANDARD ||
              prop == propCUDA_STANDARD || prop == propOBJC_STANDARD ||
              prop == propOBJCXX_STANDARD) {
     if (value) {
-      impl->LanguageStandardProperties[prop] =
-        BTs<std::string>(value, impl->Makefile->GetBacktrace());
+      this->impl->LanguageStandardProperties[prop] =
+        BTs<std::string>(value, this->impl->Makefile->GetBacktrace());
     } else {
-      impl->LanguageStandardProperties.erase(prop);
+      this->impl->LanguageStandardProperties.erase(prop);
     }
   } else {
-    impl->Properties.SetProperty(prop, value);
+    this->impl->Properties.SetProperty(prop, value);
   }
 }
 
@@ -1363,102 +1369,102 @@ void cmTarget::AppendProperty(const std::string& prop,
                               const std::string& value, bool asString)
 {
   if (prop == "NAME") {
-    impl->Makefile->IssueMessage(MessageType::FATAL_ERROR,
-                                 "NAME property is read-only\n");
+    this->impl->Makefile->IssueMessage(MessageType::FATAL_ERROR,
+                                       "NAME property is read-only\n");
     return;
   }
   if (prop == "EXPORT_NAME" && this->IsImported()) {
     std::ostringstream e;
     e << "EXPORT_NAME property can't be set on imported targets (\""
-      << impl->Name << "\")\n";
-    impl->Makefile->IssueMessage(MessageType::FATAL_ERROR, e.str());
+      << this->impl->Name << "\")\n";
+    this->impl->Makefile->IssueMessage(MessageType::FATAL_ERROR, e.str());
     return;
   }
   if (prop == "SOURCES" && this->IsImported()) {
     std::ostringstream e;
-    e << "SOURCES property can't be set on imported targets (\"" << impl->Name
-      << "\")\n";
-    impl->Makefile->IssueMessage(MessageType::FATAL_ERROR, e.str());
+    e << "SOURCES property can't be set on imported targets (\""
+      << this->impl->Name << "\")\n";
+    this->impl->Makefile->IssueMessage(MessageType::FATAL_ERROR, e.str());
     return;
   }
   if (prop == "IMPORTED_GLOBAL") {
     std::ostringstream e;
     e << "IMPORTED_GLOBAL property can't be appended, only set on imported "
          "targets (\""
-      << impl->Name << "\")\n";
-    impl->Makefile->IssueMessage(MessageType::FATAL_ERROR, e.str());
+      << this->impl->Name << "\")\n";
+    this->impl->Makefile->IssueMessage(MessageType::FATAL_ERROR, e.str());
     return;
   }
   if (prop == "INCLUDE_DIRECTORIES") {
     if (!value.empty()) {
-      impl->IncludeDirectoriesEntries.emplace_back(value);
-      cmListFileBacktrace lfbt = impl->Makefile->GetBacktrace();
-      impl->IncludeDirectoriesBacktraces.push_back(lfbt);
+      this->impl->IncludeDirectoriesEntries.emplace_back(value);
+      cmListFileBacktrace lfbt = this->impl->Makefile->GetBacktrace();
+      this->impl->IncludeDirectoriesBacktraces.push_back(lfbt);
     }
   } else if (prop == "COMPILE_OPTIONS") {
     if (!value.empty()) {
-      impl->CompileOptionsEntries.emplace_back(value);
-      cmListFileBacktrace lfbt = impl->Makefile->GetBacktrace();
-      impl->CompileOptionsBacktraces.push_back(lfbt);
+      this->impl->CompileOptionsEntries.emplace_back(value);
+      cmListFileBacktrace lfbt = this->impl->Makefile->GetBacktrace();
+      this->impl->CompileOptionsBacktraces.push_back(lfbt);
     }
   } else if (prop == "COMPILE_FEATURES") {
     if (!value.empty()) {
-      impl->CompileFeaturesEntries.emplace_back(value);
-      cmListFileBacktrace lfbt = impl->Makefile->GetBacktrace();
-      impl->CompileFeaturesBacktraces.push_back(lfbt);
+      this->impl->CompileFeaturesEntries.emplace_back(value);
+      cmListFileBacktrace lfbt = this->impl->Makefile->GetBacktrace();
+      this->impl->CompileFeaturesBacktraces.push_back(lfbt);
     }
   } else if (prop == "COMPILE_DEFINITIONS") {
     if (!value.empty()) {
-      impl->CompileDefinitionsEntries.emplace_back(value);
-      cmListFileBacktrace lfbt = impl->Makefile->GetBacktrace();
-      impl->CompileDefinitionsBacktraces.push_back(lfbt);
+      this->impl->CompileDefinitionsEntries.emplace_back(value);
+      cmListFileBacktrace lfbt = this->impl->Makefile->GetBacktrace();
+      this->impl->CompileDefinitionsBacktraces.push_back(lfbt);
     }
   } else if (prop == "LINK_OPTIONS") {
     if (!value.empty()) {
-      impl->LinkOptionsEntries.emplace_back(value);
-      cmListFileBacktrace lfbt = impl->Makefile->GetBacktrace();
-      impl->LinkOptionsBacktraces.push_back(lfbt);
+      this->impl->LinkOptionsEntries.emplace_back(value);
+      cmListFileBacktrace lfbt = this->impl->Makefile->GetBacktrace();
+      this->impl->LinkOptionsBacktraces.push_back(lfbt);
     }
   } else if (prop == "LINK_DIRECTORIES") {
     if (!value.empty()) {
-      impl->LinkDirectoriesEntries.emplace_back(value);
-      cmListFileBacktrace lfbt = impl->Makefile->GetBacktrace();
-      impl->LinkDirectoriesBacktraces.push_back(lfbt);
+      this->impl->LinkDirectoriesEntries.emplace_back(value);
+      cmListFileBacktrace lfbt = this->impl->Makefile->GetBacktrace();
+      this->impl->LinkDirectoriesBacktraces.push_back(lfbt);
     }
   } else if (prop == "PRECOMPILE_HEADERS") {
     if (this->GetProperty("PRECOMPILE_HEADERS_REUSE_FROM")) {
       std::ostringstream e;
       e << "PRECOMPILE_HEADERS_REUSE_FROM property is already set on target "
            "(\""
-        << impl->Name << "\")\n";
-      impl->Makefile->IssueMessage(MessageType::FATAL_ERROR, e.str());
+        << this->impl->Name << "\")\n";
+      this->impl->Makefile->IssueMessage(MessageType::FATAL_ERROR, e.str());
       return;
     }
     if (!value.empty()) {
-      impl->PrecompileHeadersEntries.emplace_back(value);
-      cmListFileBacktrace lfbt = impl->Makefile->GetBacktrace();
-      impl->PrecompileHeadersBacktraces.push_back(lfbt);
+      this->impl->PrecompileHeadersEntries.emplace_back(value);
+      cmListFileBacktrace lfbt = this->impl->Makefile->GetBacktrace();
+      this->impl->PrecompileHeadersBacktraces.push_back(lfbt);
     }
   } else if (prop == "LINK_LIBRARIES") {
     if (!value.empty()) {
-      cmListFileBacktrace lfbt = impl->Makefile->GetBacktrace();
-      impl->LinkImplementationPropertyEntries.emplace_back(value);
-      impl->LinkImplementationPropertyBacktraces.push_back(lfbt);
+      cmListFileBacktrace lfbt = this->impl->Makefile->GetBacktrace();
+      this->impl->LinkImplementationPropertyEntries.emplace_back(value);
+      this->impl->LinkImplementationPropertyBacktraces.push_back(lfbt);
     }
   } else if (prop == "SOURCES") {
-    cmListFileBacktrace lfbt = impl->Makefile->GetBacktrace();
-    impl->SourceEntries.emplace_back(value);
-    impl->SourceBacktraces.push_back(lfbt);
+    cmListFileBacktrace lfbt = this->impl->Makefile->GetBacktrace();
+    this->impl->SourceEntries.emplace_back(value);
+    this->impl->SourceBacktraces.push_back(lfbt);
   } else if (cmHasLiteralPrefix(prop, "IMPORTED_LIBNAME")) {
-    impl->Makefile->IssueMessage(MessageType::FATAL_ERROR,
-                                 prop + " property may not be APPENDed.");
+    this->impl->Makefile->IssueMessage(
+      MessageType::FATAL_ERROR, prop + " property may not be APPENDed.");
   } else if (prop == "C_STANDARD" || prop == "CXX_STANDARD" ||
              prop == "CUDA_STANDARD" || prop == "OBJC_STANDARD" ||
              prop == "OBJCXX_STANDARD") {
-    impl->Makefile->IssueMessage(MessageType::FATAL_ERROR,
-                                 prop + " property may not be appended.");
+    this->impl->Makefile->IssueMessage(
+      MessageType::FATAL_ERROR, prop + " property may not be appended.");
   } else {
-    impl->Properties.AppendProperty(prop, value, asString);
+    this->impl->Properties.AppendProperty(prop, value, asString);
   }
 }
 
@@ -1471,17 +1477,17 @@ void cmTarget::AppendBuildInterfaceIncludes()
       !this->IsExecutableWithExports()) {
     return;
   }
-  if (impl->BuildInterfaceIncludesAppended) {
+  if (this->impl->BuildInterfaceIncludesAppended) {
     return;
   }
-  impl->BuildInterfaceIncludesAppended = true;
+  this->impl->BuildInterfaceIncludesAppended = true;
 
-  if (impl->Makefile->IsOn("CMAKE_INCLUDE_CURRENT_DIR_IN_INTERFACE")) {
-    std::string dirs = impl->Makefile->GetCurrentBinaryDirectory();
+  if (this->impl->Makefile->IsOn("CMAKE_INCLUDE_CURRENT_DIR_IN_INTERFACE")) {
+    std::string dirs = this->impl->Makefile->GetCurrentBinaryDirectory();
     if (!dirs.empty()) {
       dirs += ';';
     }
-    dirs += impl->Makefile->GetCurrentSourceDirectory();
+    dirs += this->impl->Makefile->GetCurrentSourceDirectory();
     if (!dirs.empty()) {
       this->AppendProperty("INTERFACE_INCLUDE_DIRECTORIES",
                            ("$<BUILD_INTERFACE:" + dirs + ">"));
@@ -1492,67 +1498,67 @@ void cmTarget::AppendBuildInterfaceIncludes()
 void cmTarget::InsertInclude(std::string const& entry,
                              cmListFileBacktrace const& bt, bool before)
 {
-  auto position = before ? impl->IncludeDirectoriesEntries.begin()
-                         : impl->IncludeDirectoriesEntries.end();
+  auto position = before ? this->impl->IncludeDirectoriesEntries.begin()
+                         : this->impl->IncludeDirectoriesEntries.end();
 
-  auto btPosition = before ? impl->IncludeDirectoriesBacktraces.begin()
-                           : impl->IncludeDirectoriesBacktraces.end();
+  auto btPosition = before ? this->impl->IncludeDirectoriesBacktraces.begin()
+                           : this->impl->IncludeDirectoriesBacktraces.end();
 
-  impl->IncludeDirectoriesEntries.insert(position, entry);
-  impl->IncludeDirectoriesBacktraces.insert(btPosition, bt);
+  this->impl->IncludeDirectoriesEntries.insert(position, entry);
+  this->impl->IncludeDirectoriesBacktraces.insert(btPosition, bt);
 }
 
 void cmTarget::InsertCompileOption(std::string const& entry,
                                    cmListFileBacktrace const& bt, bool before)
 {
-  auto position = before ? impl->CompileOptionsEntries.begin()
-                         : impl->CompileOptionsEntries.end();
+  auto position = before ? this->impl->CompileOptionsEntries.begin()
+                         : this->impl->CompileOptionsEntries.end();
 
-  auto btPosition = before ? impl->CompileOptionsBacktraces.begin()
-                           : impl->CompileOptionsBacktraces.end();
+  auto btPosition = before ? this->impl->CompileOptionsBacktraces.begin()
+                           : this->impl->CompileOptionsBacktraces.end();
 
-  impl->CompileOptionsEntries.insert(position, entry);
-  impl->CompileOptionsBacktraces.insert(btPosition, bt);
+  this->impl->CompileOptionsEntries.insert(position, entry);
+  this->impl->CompileOptionsBacktraces.insert(btPosition, bt);
 }
 
 void cmTarget::InsertCompileDefinition(std::string const& entry,
                                        cmListFileBacktrace const& bt)
 {
-  impl->CompileDefinitionsEntries.push_back(entry);
-  impl->CompileDefinitionsBacktraces.push_back(bt);
+  this->impl->CompileDefinitionsEntries.push_back(entry);
+  this->impl->CompileDefinitionsBacktraces.push_back(bt);
 }
 
 void cmTarget::InsertLinkOption(std::string const& entry,
                                 cmListFileBacktrace const& bt, bool before)
 {
-  auto position =
-    before ? impl->LinkOptionsEntries.begin() : impl->LinkOptionsEntries.end();
+  auto position = before ? this->impl->LinkOptionsEntries.begin()
+                         : this->impl->LinkOptionsEntries.end();
 
-  auto btPosition = before ? impl->LinkOptionsBacktraces.begin()
-                           : impl->LinkOptionsBacktraces.end();
+  auto btPosition = before ? this->impl->LinkOptionsBacktraces.begin()
+                           : this->impl->LinkOptionsBacktraces.end();
 
-  impl->LinkOptionsEntries.insert(position, entry);
-  impl->LinkOptionsBacktraces.insert(btPosition, bt);
+  this->impl->LinkOptionsEntries.insert(position, entry);
+  this->impl->LinkOptionsBacktraces.insert(btPosition, bt);
 }
 
 void cmTarget::InsertLinkDirectory(std::string const& entry,
                                    cmListFileBacktrace const& bt, bool before)
 {
-  auto position = before ? impl->LinkDirectoriesEntries.begin()
-                         : impl->LinkDirectoriesEntries.end();
+  auto position = before ? this->impl->LinkDirectoriesEntries.begin()
+                         : this->impl->LinkDirectoriesEntries.end();
 
-  auto btPosition = before ? impl->LinkDirectoriesBacktraces.begin()
-                           : impl->LinkDirectoriesBacktraces.end();
+  auto btPosition = before ? this->impl->LinkDirectoriesBacktraces.begin()
+                           : this->impl->LinkDirectoriesBacktraces.end();
 
-  impl->LinkDirectoriesEntries.insert(position, entry);
-  impl->LinkDirectoriesBacktraces.insert(btPosition, bt);
+  this->impl->LinkDirectoriesEntries.insert(position, entry);
+  this->impl->LinkDirectoriesBacktraces.insert(btPosition, bt);
 }
 
 void cmTarget::InsertPrecompileHeader(std::string const& entry,
                                       cmListFileBacktrace const& bt)
 {
-  impl->PrecompileHeadersEntries.push_back(entry);
-  impl->PrecompileHeadersBacktraces.push_back(bt);
+  this->impl->PrecompileHeadersEntries.push_back(entry);
+  this->impl->PrecompileHeadersBacktraces.push_back(bt);
 }
 
 static void cmTargetCheckLINK_INTERFACE_LIBRARIES(const std::string& prop,
@@ -1721,19 +1727,19 @@ cmProp cmTarget::GetProperty(const std::string& prop) const
     if (prop == propC_STANDARD || prop == propCXX_STANDARD ||
         prop == propCUDA_STANDARD || prop == propOBJC_STANDARD ||
         prop == propOBJCXX_STANDARD) {
-      auto propertyIter = impl->LanguageStandardProperties.find(prop);
-      if (propertyIter == impl->LanguageStandardProperties.end()) {
+      auto propertyIter = this->impl->LanguageStandardProperties.find(prop);
+      if (propertyIter == this->impl->LanguageStandardProperties.end()) {
         return nullptr;
       }
       return &(propertyIter->second.Value);
     }
     if (prop == propLINK_LIBRARIES) {
-      if (impl->LinkImplementationPropertyEntries.empty()) {
+      if (this->impl->LinkImplementationPropertyEntries.empty()) {
         return nullptr;
       }
 
       static std::string output;
-      output = cmJoin(impl->LinkImplementationPropertyEntries, ";");
+      output = cmJoin(this->impl->LinkImplementationPropertyEntries, ";");
       return &output;
     }
     // the type property returns what type the target is
@@ -1741,70 +1747,71 @@ cmProp cmTarget::GetProperty(const std::string& prop) const
       return &cmState::GetTargetTypeName(this->GetType());
     }
     if (prop == propINCLUDE_DIRECTORIES) {
-      if (impl->IncludeDirectoriesEntries.empty()) {
+      if (this->impl->IncludeDirectoriesEntries.empty()) {
         return nullptr;
       }
 
       static std::string output;
-      output = cmJoin(impl->IncludeDirectoriesEntries, ";");
+      output = cmJoin(this->impl->IncludeDirectoriesEntries, ";");
       return &output;
     }
     if (prop == propCOMPILE_FEATURES) {
-      if (impl->CompileFeaturesEntries.empty()) {
+      if (this->impl->CompileFeaturesEntries.empty()) {
         return nullptr;
       }
 
       static std::string output;
-      output = cmJoin(impl->CompileFeaturesEntries, ";");
+      output = cmJoin(this->impl->CompileFeaturesEntries, ";");
       return &output;
     }
     if (prop == propCOMPILE_OPTIONS) {
-      if (impl->CompileOptionsEntries.empty()) {
+      if (this->impl->CompileOptionsEntries.empty()) {
         return nullptr;
       }
 
       static std::string output;
-      output = cmJoin(impl->CompileOptionsEntries, ";");
+      output = cmJoin(this->impl->CompileOptionsEntries, ";");
       return &output;
     }
     if (prop == propCOMPILE_DEFINITIONS) {
-      if (impl->CompileDefinitionsEntries.empty()) {
+      if (this->impl->CompileDefinitionsEntries.empty()) {
         return nullptr;
       }
 
       static std::string output;
-      output = cmJoin(impl->CompileDefinitionsEntries, ";");
+      output = cmJoin(this->impl->CompileDefinitionsEntries, ";");
       return &output;
     }
     if (prop == propLINK_OPTIONS) {
-      if (impl->LinkOptionsEntries.empty()) {
+      if (this->impl->LinkOptionsEntries.empty()) {
         return nullptr;
       }
 
       static std::string output;
-      output = cmJoin(impl->LinkOptionsEntries, ";");
+      output = cmJoin(this->impl->LinkOptionsEntries, ";");
       return &output;
     }
     if (prop == propLINK_DIRECTORIES) {
-      if (impl->LinkDirectoriesEntries.empty()) {
+      if (this->impl->LinkDirectoriesEntries.empty()) {
         return nullptr;
       }
 
       static std::string output;
-      output = cmJoin(impl->LinkDirectoriesEntries, ";");
+      output = cmJoin(this->impl->LinkDirectoriesEntries, ";");
 
       return &output;
     }
     if (prop == propMANUALLY_ADDED_DEPENDENCIES) {
-      if (impl->Utilities.empty()) {
+      if (this->impl->Utilities.empty()) {
         return nullptr;
       }
 
       static std::string output;
       static std::vector<std::string> utilities;
-      utilities.resize(impl->Utilities.size());
+      utilities.resize(this->impl->Utilities.size());
       std::transform(
-        impl->Utilities.cbegin(), impl->Utilities.cend(), utilities.begin(),
+        this->impl->Utilities.cbegin(), this->impl->Utilities.cend(),
+        utilities.begin(),
         [](const BT<std::pair<std::string, bool>>& item) -> std::string {
           return item.Value.first;
         });
@@ -1812,12 +1819,12 @@ cmProp cmTarget::GetProperty(const std::string& prop) const
       return &output;
     }
     if (prop == propPRECOMPILE_HEADERS) {
-      if (impl->PrecompileHeadersEntries.empty()) {
+      if (this->impl->PrecompileHeadersEntries.empty()) {
         return nullptr;
       }
 
       static std::string output;
-      output = cmJoin(impl->PrecompileHeadersEntries, ";");
+      output = cmJoin(this->impl->PrecompileHeadersEntries, ";");
       return &output;
     }
     if (prop == propIMPORTED) {
@@ -1830,24 +1837,25 @@ cmProp cmTarget::GetProperty(const std::string& prop) const
       return &this->GetName();
     }
     if (prop == propBINARY_DIR) {
-      return &impl->Makefile->GetStateSnapshot()
+      return &this->impl->Makefile->GetStateSnapshot()
                 .GetDirectory()
                 .GetCurrentBinary();
     }
     if (prop == propSOURCE_DIR) {
-      return &impl->Makefile->GetStateSnapshot()
+      return &this->impl->Makefile->GetStateSnapshot()
                 .GetDirectory()
                 .GetCurrentSource();
     }
   }
 
-  cmProp retVal = impl->Properties.GetPropertyValue(prop);
+  cmProp retVal = this->impl->Properties.GetPropertyValue(prop);
   if (!retVal) {
-    const bool chain =
-      impl->Makefile->GetState()->IsPropertyChained(prop, cmProperty::TARGET);
+    const bool chain = this->impl->Makefile->GetState()->IsPropertyChained(
+      prop, cmProperty::TARGET);
     if (chain) {
-      return impl->Makefile->GetStateSnapshot().GetDirectory().GetProperty(
-        prop, chain);
+      return this->impl->Makefile->GetStateSnapshot()
+        .GetDirectory()
+        .GetProperty(prop, chain);
     }
     return nullptr;
   }
@@ -1872,32 +1880,32 @@ bool cmTarget::GetPropertyAsBool(const std::string& prop) const
 
 cmPropertyMap const& cmTarget::GetProperties() const
 {
-  return impl->Properties;
+  return this->impl->Properties;
 }
 
 bool cmTarget::IsDLLPlatform() const
 {
-  return impl->IsDLLPlatform;
+  return this->impl->IsDLLPlatform;
 }
 
 bool cmTarget::IsAIX() const
 {
-  return impl->IsAIX;
+  return this->impl->IsAIX;
 }
 
 bool cmTarget::IsImported() const
 {
-  return impl->IsImportedTarget;
+  return this->impl->IsImportedTarget;
 }
 
 bool cmTarget::IsImportedGloballyVisible() const
 {
-  return impl->ImportedGloballyVisible;
+  return this->impl->ImportedGloballyVisible;
 }
 
 bool cmTarget::IsPerConfig() const
 {
-  return impl->PerConfig;
+  return this->impl->PerConfig;
 }
 
 bool cmTarget::CanCompileSources() const
@@ -1952,8 +1960,8 @@ const char* cmTarget::GetSuffixVariableInternal(
                     ? "CMAKE_SHARED_LIBRARY_SUFFIX"
                     : "CMAKE_EXECUTABLE_SUFFIX");
         case cmStateEnums::ImportLibraryArtifact:
-          return (impl->IsAIX ? "CMAKE_AIX_IMPORT_FILE_SUFFIX"
-                              : "CMAKE_IMPORT_LIBRARY_SUFFIX");
+          return (this->impl->IsAIX ? "CMAKE_AIX_IMPORT_FILE_SUFFIX"
+                                    : "CMAKE_IMPORT_LIBRARY_SUFFIX");
       }
       break;
     default:
@@ -1993,8 +2001,8 @@ const char* cmTarget::GetPrefixVariableInternal(
                     ? "CMAKE_SHARED_LIBRARY_PREFIX"
                     : "");
         case cmStateEnums::ImportLibraryArtifact:
-          return (impl->IsAIX ? "CMAKE_AIX_IMPORT_FILE_PREFIX"
-                              : "CMAKE_IMPORT_LIBRARY_PREFIX");
+          return (this->impl->IsAIX ? "CMAKE_AIX_IMPORT_FILE_PREFIX"
+                                    : "CMAKE_IMPORT_LIBRARY_PREFIX");
       }
       break;
     default:
@@ -2076,7 +2084,7 @@ std::string cmTarget::ImportedGetFullPath(
 
       switch (this->GetPolicyStatus(cmPolicies::CMP0111)) {
         case cmPolicies::WARN:
-          impl->Makefile->IssueMessage(
+          this->impl->Makefile->IssueMessage(
             MessageType::AUTHOR_WARNING,
             cmPolicies::GetPolicyWarning(cmPolicies::CMP0111) + "\n" +
               message());
@@ -2084,7 +2092,8 @@ std::string cmTarget::ImportedGetFullPath(
         case cmPolicies::OLD:
           break;
         default:
-          impl->Makefile->IssueMessage(MessageType::FATAL_ERROR, message());
+          this->impl->Makefile->IssueMessage(MessageType::FATAL_ERROR,
+                                             message());
       }
     }
 
diff --git a/Source/cmTarget.h b/Source/cmTarget.h
index 27f0c59067..3066eb2c77 100644
--- a/Source/cmTarget.h
+++ b/Source/cmTarget.h
@@ -172,7 +172,7 @@ public:
   void SetProperty(const std::string& prop, const char* value);
   void SetProperty(const std::string& prop, const std::string& value)
   {
-    SetProperty(prop, value.c_str());
+    this->SetProperty(prop, value.c_str());
   }
   void AppendProperty(const std::string& prop, const std::string& value,
                       bool asString = false);
diff --git a/Source/cmTargetIncludeDirectoriesCommand.cxx b/Source/cmTargetIncludeDirectoriesCommand.cxx
index bf4cc090f3..3897499f30 100644
--- a/Source/cmTargetIncludeDirectoriesCommand.cxx
+++ b/Source/cmTargetIncludeDirectoriesCommand.cxx
@@ -84,8 +84,8 @@ void TargetIncludeDirectoriesImpl::HandleInterfaceContent(
   cmTarget* tgt, const std::vector<std::string>& content, bool prepend,
   bool system)
 {
-  cmTargetPropCommandBase::HandleInterfaceContent(tgt, content, prepend,
-                                                  system);
+  this->cmTargetPropCommandBase::HandleInterfaceContent(tgt, content, prepend,
+                                                        system);
   if (system) {
     std::string joined = this->Join(content);
     tgt->AppendProperty("INTERFACE_SYSTEM_INCLUDE_DIRECTORIES", joined);
diff --git a/Source/cmTargetPrecompileHeadersCommand.cxx b/Source/cmTargetPrecompileHeadersCommand.cxx
index 0670bd962a..a5066cc2a5 100644
--- a/Source/cmTargetPrecompileHeadersCommand.cxx
+++ b/Source/cmTargetPrecompileHeadersCommand.cxx
@@ -57,7 +57,7 @@ private:
                               bool prepend, bool system) override
   {
     std::string const& base = this->Makefile->GetCurrentSourceDirectory();
-    cmTargetPropCommandBase::HandleInterfaceContent(
+    this->cmTargetPropCommandBase::HandleInterfaceContent(
       tgt, ConvertToAbsoluteContent(content, base), prepend, system);
   }
 
diff --git a/Source/cmTargetSourcesCommand.cxx b/Source/cmTargetSourcesCommand.cxx
index a1fbc9b9b0..26282effb6 100644
--- a/Source/cmTargetSourcesCommand.cxx
+++ b/Source/cmTargetSourcesCommand.cxx
@@ -25,8 +25,9 @@ protected:
                               const std::vector<std::string>& content,
                               bool prepend, bool system) override
   {
-    cmTargetPropCommandBase::HandleInterfaceContent(
-      tgt, ConvertToAbsoluteContent(tgt, content, true), prepend, system);
+    this->cmTargetPropCommandBase::HandleInterfaceContent(
+      tgt, this->ConvertToAbsoluteContent(tgt, content, true), prepend,
+      system);
   }
 
 private:
@@ -43,7 +44,8 @@ private:
                            bool /*prepend*/, bool /*system*/) override
   {
     tgt->AppendProperty(
-      "SOURCES", this->Join(ConvertToAbsoluteContent(tgt, content, false)));
+      "SOURCES",
+      this->Join(this->ConvertToAbsoluteContent(tgt, content, false)));
     return true; // Successfully handled.
   }
 
diff --git a/Source/cmTestGenerator.cxx b/Source/cmTestGenerator.cxx
index da4593f67f..7022c4eb1e 100644
--- a/Source/cmTestGenerator.cxx
+++ b/Source/cmTestGenerator.cxx
@@ -147,7 +147,7 @@ void cmTestGenerator::GenerateScriptForConfig(std::ostream& os,
 
   // Evaluate command line arguments
   std::vector<std::string> argv =
-    EvaluateCommandLineArguments(this->Test->GetCommand(), ge, config);
+    this->EvaluateCommandLineArguments(this->Test->GetCommand(), ge, config);
 
   // Expand arguments if COMMAND_EXPAND_LISTS is set
   if (this->Test->GetCommandExpandLists()) {
diff --git a/Source/cmTimestamp.cxx b/Source/cmTimestamp.cxx
index 67f7e11461..7fb69bf7ff 100644
--- a/Source/cmTimestamp.cxx
+++ b/Source/cmTimestamp.cxx
@@ -38,7 +38,7 @@ std::string cmTimestamp::CurrentTime(const std::string& formatString,
     return std::string();
   }
 
-  return CreateTimestampFromTimeT(currentTimeT, formatString, utcFlag);
+  return this->CreateTimestampFromTimeT(currentTimeT, formatString, utcFlag);
 }
 
 std::string cmTimestamp::FileModificationTime(const char* path,
@@ -53,7 +53,7 @@ std::string cmTimestamp::FileModificationTime(const char* path,
   }
 
   time_t mtime = cmsys::SystemTools::ModifiedTime(real_path);
-  return CreateTimestampFromTimeT(mtime, formatString, utcFlag);
+  return this->CreateTimestampFromTimeT(mtime, formatString, utcFlag);
 }
 
 std::string cmTimestamp::CreateTimestampFromTimeT(time_t timeT,
@@ -90,7 +90,7 @@ std::string cmTimestamp::CreateTimestampFromTimeT(time_t timeT,
                                             : static_cast<char>(0);
 
     if (c1 == '%' && c2 != 0) {
-      result += AddTimestampComponent(c2, timeStruct, timeT);
+      result += this->AddTimestampComponent(c2, timeStruct, timeT);
       ++i;
     } else {
       result += c1;
diff --git a/Source/cmUVHandlePtr.cxx b/Source/cmUVHandlePtr.cxx
index df2f64ec5e..e556a11b19 100644
--- a/Source/cmUVHandlePtr.cxx
+++ b/Source/cmUVHandlePtr.cxx
@@ -80,7 +80,7 @@ struct uv_handle_deleter
 template <typename T>
 void uv_handle_ptr_base_<T>::allocate(void* data)
 {
-  reset();
+  this->reset();
 
   /*
     We use calloc since we know all these types are c structs
@@ -88,32 +88,33 @@ void uv_handle_ptr_base_<T>::allocate(void* data)
     but casting from uv_handle_t to certain other types -- namely
     uv_timer_t -- triggers a cast_align warning on certain systems.
   */
-  handle.reset(static_cast<T*>(calloc(1, sizeof(T))), uv_handle_deleter<T>());
-  handle->data = data;
+  this->handle.reset(static_cast<T*>(calloc(1, sizeof(T))),
+                     uv_handle_deleter<T>());
+  this->handle->data = data;
 }
 
 template <typename T>
 void uv_handle_ptr_base_<T>::reset()
 {
-  handle.reset();
+  this->handle.reset();
 }
 
 template <typename T>
 uv_handle_ptr_base_<T>::operator uv_handle_t*()
 {
-  return reinterpret_cast<uv_handle_t*>(handle.get());
+  return reinterpret_cast<uv_handle_t*>(this->handle.get());
 }
 
 template <typename T>
 T* uv_handle_ptr_base_<T>::operator->() const noexcept
 {
-  return handle.get();
+  return this->handle.get();
 }
 
 template <typename T>
 T* uv_handle_ptr_base_<T>::get() const
 {
-  return handle.get();
+  return this->handle.get();
 }
 
 template <typename T>
@@ -146,7 +147,7 @@ struct uv_handle_deleter<uv_async_t>
 
   void operator()(uv_async_t* handle)
   {
-    std::lock_guard<std::mutex> lock(*handleMutex);
+    std::lock_guard<std::mutex> lock(*this->handleMutex);
     handle_default_delete(handle);
   }
 };
@@ -164,8 +165,8 @@ void uv_async_ptr::send()
 
 int uv_async_ptr::init(uv_loop_t& loop, uv_async_cb async_cb, void* data)
 {
-  allocate(data);
-  return uv_async_init(&loop, handle.get(), async_cb);
+  this->allocate(data);
+  return uv_async_init(&loop, this->handle.get(), async_cb);
 }
 #endif
 
@@ -183,62 +184,62 @@ struct uv_handle_deleter<uv_signal_t>
 
 int uv_signal_ptr::init(uv_loop_t& loop, void* data)
 {
-  allocate(data);
-  return uv_signal_init(&loop, handle.get());
+  this->allocate(data);
+  return uv_signal_init(&loop, this->handle.get());
 }
 
 int uv_signal_ptr::start(uv_signal_cb cb, int signum)
 {
-  assert(handle);
+  assert(this->handle);
   return uv_signal_start(*this, cb, signum);
 }
 
 void uv_signal_ptr::stop()
 {
-  if (handle) {
+  if (this->handle) {
     uv_signal_stop(*this);
   }
 }
 
 int uv_pipe_ptr::init(uv_loop_t& loop, int ipc, void* data)
 {
-  allocate(data);
+  this->allocate(data);
   return uv_pipe_init(&loop, *this, ipc);
 }
 
 uv_pipe_ptr::operator uv_stream_t*() const
 {
-  return reinterpret_cast<uv_stream_t*>(handle.get());
+  return reinterpret_cast<uv_stream_t*>(this->handle.get());
 }
 
 int uv_process_ptr::spawn(uv_loop_t& loop, uv_process_options_t const& options,
                           void* data)
 {
-  allocate(data);
+  this->allocate(data);
   return uv_spawn(&loop, *this, &options);
 }
 
 int uv_timer_ptr::init(uv_loop_t& loop, void* data)
 {
-  allocate(data);
+  this->allocate(data);
   return uv_timer_init(&loop, *this);
 }
 
 int uv_timer_ptr::start(uv_timer_cb cb, uint64_t timeout, uint64_t repeat)
 {
-  assert(handle);
+  assert(this->handle);
   return uv_timer_start(*this, cb, timeout, repeat);
 }
 
 #ifndef CMAKE_BOOTSTRAP
 uv_tty_ptr::operator uv_stream_t*() const
 {
-  return reinterpret_cast<uv_stream_t*>(handle.get());
+  return reinterpret_cast<uv_stream_t*>(this->handle.get());
 }
 
 int uv_tty_ptr::init(uv_loop_t& loop, int fd, int readable, void* data)
 {
-  allocate(data);
+  this->allocate(data);
   return uv_tty_init(&loop, *this, fd, readable);
 }
 #endif
diff --git a/Source/cmUVHandlePtr.h b/Source/cmUVHandlePtr.h
index d9de7f3daf..356e2272ea 100644
--- a/Source/cmUVHandlePtr.h
+++ b/Source/cmUVHandlePtr.h
@@ -128,7 +128,7 @@ public:
   // dtors to work.  Some compilers do not like '= default' here.
   uv_handle_ptr_base_() {} // NOLINT(modernize-use-equals-default)
   uv_handle_ptr_base_(std::nullptr_t) {}
-  ~uv_handle_ptr_base_() { reset(); }
+  ~uv_handle_ptr_base_() { this->reset(); }
 
   /**
    * Properly close the handle if needed and sets the inner handle to nullptr
diff --git a/Source/cmUuid.cxx b/Source/cmUuid.cxx
index cd52b3f309..2513303cd9 100644
--- a/Source/cmUuid.cxx
+++ b/Source/cmUuid.cxx
@@ -82,7 +82,7 @@ bool cmUuid::StringToBinary(std::string const& input,
       return false;
     }
     size_t digits = kUuidGroups[i] * 2;
-    if (!StringToBinaryImpl(input.substr(index, digits), output)) {
+    if (!this->StringToBinaryImpl(input.substr(index, digits), output)) {
       return false;
     }
 
@@ -134,12 +134,12 @@ bool cmUuid::StringToBinaryImpl(std::string const& input,
 
   for (size_t i = 0; i < input.size(); i += 2) {
     char c1 = 0;
-    if (!IntFromHexDigit(input[i], c1)) {
+    if (!this->IntFromHexDigit(input[i], c1)) {
       return false;
     }
 
     char c2 = 0;
-    if (!IntFromHexDigit(input[i + 1], c2)) {
+    if (!this->IntFromHexDigit(input[i + 1], c2)) {
       return false;
     }
 
diff --git a/Source/cmWorkerPool.cxx b/Source/cmWorkerPool.cxx
index 12aba4f962..f2c091f64b 100644
--- a/Source/cmWorkerPool.cxx
+++ b/Source/cmWorkerPool.cxx
@@ -50,11 +50,14 @@ public:
   bool startRead(DataFunction dataFunction, EndFunction endFunction);
 
   //! libuv pipe
-  uv_pipe_t* uv_pipe() const { return UVPipe_.get(); }
+  uv_pipe_t* uv_pipe() const { return this->UVPipe_.get(); }
   //! uv_pipe() casted to libuv stream
-  uv_stream_t* uv_stream() const { return static_cast<uv_stream_t*>(UVPipe_); }
+  uv_stream_t* uv_stream() const
+  {
+    return static_cast<uv_stream_t*>(this->UVPipe_);
+  }
   //! uv_pipe() casted to libuv handle
-  uv_handle_t* uv_handle() { return static_cast<uv_handle_t*>(UVPipe_); }
+  uv_handle_t* uv_handle() { return static_cast<uv_handle_t*>(this->UVPipe_); }
 
 private:
   // -- Libuv callbacks
@@ -71,37 +74,37 @@ private:
 
 void cmUVPipeBuffer::reset()
 {
-  if (UVPipe_.get() != nullptr) {
-    EndFunction_ = nullptr;
-    DataFunction_ = nullptr;
-    Buffer_.clear();
-    Buffer_.shrink_to_fit();
-    UVPipe_.reset();
+  if (this->UVPipe_.get() != nullptr) {
+    this->EndFunction_ = nullptr;
+    this->DataFunction_ = nullptr;
+    this->Buffer_.clear();
+    this->Buffer_.shrink_to_fit();
+    this->UVPipe_.reset();
   }
 }
 
 bool cmUVPipeBuffer::init(uv_loop_t* uv_loop)
 {
-  reset();
+  this->reset();
   if (uv_loop == nullptr) {
     return false;
   }
-  int ret = UVPipe_.init(*uv_loop, 0, this);
+  int ret = this->UVPipe_.init(*uv_loop, 0, this);
   return (ret == 0);
 }
 
 bool cmUVPipeBuffer::startRead(DataFunction dataFunction,
                                EndFunction endFunction)
 {
-  if (UVPipe_.get() == nullptr) {
+  if (this->UVPipe_.get() == nullptr) {
     return false;
   }
   if (!dataFunction || !endFunction) {
     return false;
   }
-  DataFunction_ = std::move(dataFunction);
-  EndFunction_ = std::move(endFunction);
-  int ret = uv_read_start(uv_stream(), &cmUVPipeBuffer::UVAlloc,
+  this->DataFunction_ = std::move(dataFunction);
+  this->EndFunction_ = std::move(endFunction);
+  int ret = uv_read_start(this->uv_stream(), &cmUVPipeBuffer::UVAlloc,
                           &cmUVPipeBuffer::UVData);
   return (ret == 0);
 }
@@ -153,10 +156,10 @@ public:
 
 public:
   // -- Const accessors
-  SetupT const& Setup() const { return Setup_; }
-  cmWorkerPool::ProcessResultT* Result() const { return Setup_.Result; }
-  bool IsStarted() const { return IsStarted_; }
-  bool IsFinished() const { return IsFinished_; }
+  SetupT const& Setup() const { return this->Setup_; }
+  cmWorkerPool::ProcessResultT* Result() const { return this->Setup_.Result; }
+  bool IsStarted() const { return this->IsStarted_; }
+  bool IsFinished() const { return this->IsFinished_; }
 
   // -- Runtime
   void setup(cmWorkerPool::ProcessResultT* result, bool mergedOutput,
@@ -193,109 +196,113 @@ void cmUVReadOnlyProcess::setup(cmWorkerPool::ProcessResultT* result,
                                 std::vector<std::string> const& command,
                                 std::string const& workingDirectory)
 {
-  Setup_.WorkingDirectory = workingDirectory;
-  Setup_.Command = command;
-  Setup_.Result = result;
-  Setup_.MergedOutput = mergedOutput;
+  this->Setup_.WorkingDirectory = workingDirectory;
+  this->Setup_.Command = command;
+  this->Setup_.Result = result;
+  this->Setup_.MergedOutput = mergedOutput;
 }
 
 bool cmUVReadOnlyProcess::start(uv_loop_t* uv_loop,
                                 std::function<void()> finishedCallback)
 {
-  if (IsStarted() || (Result() == nullptr)) {
+  if (this->IsStarted() || (this->Result() == nullptr)) {
     return false;
   }
 
   // Reset result before the start
-  Result()->reset();
+  this->Result()->reset();
 
   // Fill command string pointers
-  if (!Setup().Command.empty()) {
-    CommandPtr_.reserve(Setup().Command.size() + 1);
-    for (std::string const& arg : Setup().Command) {
-      CommandPtr_.push_back(arg.c_str());
+  if (!this->Setup().Command.empty()) {
+    this->CommandPtr_.reserve(this->Setup().Command.size() + 1);
+    for (std::string const& arg : this->Setup().Command) {
+      this->CommandPtr_.push_back(arg.c_str());
     }
-    CommandPtr_.push_back(nullptr);
+    this->CommandPtr_.push_back(nullptr);
   } else {
-    Result()->ErrorMessage = "Empty command";
+    this->Result()->ErrorMessage = "Empty command";
   }
 
-  if (!Result()->error()) {
-    if (!UVPipeOut_.init(uv_loop)) {
-      Result()->ErrorMessage = "libuv stdout pipe initialization failed";
+  if (!this->Result()->error()) {
+    if (!this->UVPipeOut_.init(uv_loop)) {
+      this->Result()->ErrorMessage = "libuv stdout pipe initialization failed";
     }
   }
-  if (!Result()->error()) {
-    if (!UVPipeErr_.init(uv_loop)) {
-      Result()->ErrorMessage = "libuv stderr pipe initialization failed";
+  if (!this->Result()->error()) {
+    if (!this->UVPipeErr_.init(uv_loop)) {
+      this->Result()->ErrorMessage = "libuv stderr pipe initialization failed";
     }
   }
-  if (!Result()->error()) {
+  if (!this->Result()->error()) {
     // -- Setup process stdio options
     // stdin
-    UVOptionsStdIO_[0].flags = UV_IGNORE;
-    UVOptionsStdIO_[0].data.stream = nullptr;
+    this->UVOptionsStdIO_[0].flags = UV_IGNORE;
+    this->UVOptionsStdIO_[0].data.stream = nullptr;
     // stdout
-    UVOptionsStdIO_[1].flags =
+    this->UVOptionsStdIO_[1].flags =
       static_cast<uv_stdio_flags>(UV_CREATE_PIPE | UV_WRITABLE_PIPE);
-    UVOptionsStdIO_[1].data.stream = UVPipeOut_.uv_stream();
+    this->UVOptionsStdIO_[1].data.stream = this->UVPipeOut_.uv_stream();
     // stderr
-    UVOptionsStdIO_[2].flags =
+    this->UVOptionsStdIO_[2].flags =
       static_cast<uv_stdio_flags>(UV_CREATE_PIPE | UV_WRITABLE_PIPE);
-    UVOptionsStdIO_[2].data.stream = UVPipeErr_.uv_stream();
+    this->UVOptionsStdIO_[2].data.stream = this->UVPipeErr_.uv_stream();
 
     // -- Setup process options
-    std::fill_n(reinterpret_cast<char*>(&UVOptions_), sizeof(UVOptions_), 0);
-    UVOptions_.exit_cb = &cmUVReadOnlyProcess::UVExit;
-    UVOptions_.file = CommandPtr_[0];
-    UVOptions_.args = const_cast<char**>(CommandPtr_.data());
-    UVOptions_.cwd = Setup_.WorkingDirectory.c_str();
-    UVOptions_.flags = UV_PROCESS_WINDOWS_HIDE;
-    UVOptions_.stdio_count = static_cast<int>(UVOptionsStdIO_.size());
-    UVOptions_.stdio = UVOptionsStdIO_.data();
+    std::fill_n(reinterpret_cast<char*>(&this->UVOptions_),
+                sizeof(this->UVOptions_), 0);
+    this->UVOptions_.exit_cb = &cmUVReadOnlyProcess::UVExit;
+    this->UVOptions_.file = this->CommandPtr_[0];
+    this->UVOptions_.args = const_cast<char**>(this->CommandPtr_.data());
+    this->UVOptions_.cwd = this->Setup_.WorkingDirectory.c_str();
+    this->UVOptions_.flags = UV_PROCESS_WINDOWS_HIDE;
+    this->UVOptions_.stdio_count =
+      static_cast<int>(this->UVOptionsStdIO_.size());
+    this->UVOptions_.stdio = this->UVOptionsStdIO_.data();
 
     // -- Spawn process
-    int uvErrorCode = UVProcess_.spawn(*uv_loop, UVOptions_, this);
+    int uvErrorCode = this->UVProcess_.spawn(*uv_loop, this->UVOptions_, this);
     if (uvErrorCode != 0) {
-      Result()->ErrorMessage = "libuv process spawn failed";
+      this->Result()->ErrorMessage = "libuv process spawn failed";
       if (const char* uvErr = uv_strerror(uvErrorCode)) {
-        Result()->ErrorMessage += ": ";
-        Result()->ErrorMessage += uvErr;
+        this->Result()->ErrorMessage += ": ";
+        this->Result()->ErrorMessage += uvErr;
       }
     }
   }
   // -- Start reading from stdio streams
-  if (!Result()->error()) {
-    if (!UVPipeOut_.startRead(
+  if (!this->Result()->error()) {
+    if (!this->UVPipeOut_.startRead(
           [this](cmUVPipeBuffer::DataRange range) {
             this->UVPipeOutData(range);
           },
           [this](ssize_t error) { this->UVPipeOutEnd(error); })) {
-      Result()->ErrorMessage = "libuv start reading from stdout pipe failed";
+      this->Result()->ErrorMessage =
+        "libuv start reading from stdout pipe failed";
     }
   }
-  if (!Result()->error()) {
-    if (!UVPipeErr_.startRead(
+  if (!this->Result()->error()) {
+    if (!this->UVPipeErr_.startRead(
           [this](cmUVPipeBuffer::DataRange range) {
             this->UVPipeErrData(range);
           },
           [this](ssize_t error) { this->UVPipeErrEnd(error); })) {
-      Result()->ErrorMessage = "libuv start reading from stderr pipe failed";
+      this->Result()->ErrorMessage =
+        "libuv start reading from stderr pipe failed";
     }
   }
 
-  if (!Result()->error()) {
-    IsStarted_ = true;
-    FinishedCallback_ = std::move(finishedCallback);
+  if (!this->Result()->error()) {
+    this->IsStarted_ = true;
+    this->FinishedCallback_ = std::move(finishedCallback);
   } else {
     // Clear libuv handles and finish
-    UVProcess_.reset();
-    UVPipeOut_.reset();
-    UVPipeErr_.reset();
-    CommandPtr_.clear();
+    this->UVProcess_.reset();
+    this->UVPipeOut_.reset();
+    this->UVPipeErr_.reset();
+    this->CommandPtr_.clear();
   }
 
-  return IsStarted();
+  return this->IsStarted();
 }
 
 void cmUVReadOnlyProcess::UVExit(uv_process_t* handle, int64_t exitStatus,
@@ -325,36 +332,36 @@ void cmUVReadOnlyProcess::UVExit(uv_process_t* handle, int64_t exitStatus,
 
 void cmUVReadOnlyProcess::UVPipeOutData(cmUVPipeBuffer::DataRange data)
 {
-  Result()->StdOut.append(data.begin(), data.end());
+  this->Result()->StdOut.append(data.begin(), data.end());
 }
 
 void cmUVReadOnlyProcess::UVPipeOutEnd(ssize_t error)
 {
   // Process pipe error
-  if ((error != 0) && !Result()->error()) {
-    Result()->ErrorMessage = cmStrCat(
+  if ((error != 0) && !this->Result()->error()) {
+    this->Result()->ErrorMessage = cmStrCat(
       "Reading from stdout pipe failed with libuv error code ", error);
   }
   // Try finish
-  UVTryFinish();
+  this->UVTryFinish();
 }
 
 void cmUVReadOnlyProcess::UVPipeErrData(cmUVPipeBuffer::DataRange data)
 {
-  std::string* str =
-    Setup_.MergedOutput ? &Result()->StdOut : &Result()->StdErr;
+  std::string* str = this->Setup_.MergedOutput ? &this->Result()->StdOut
+                                               : &this->Result()->StdErr;
   str->append(data.begin(), data.end());
 }
 
 void cmUVReadOnlyProcess::UVPipeErrEnd(ssize_t error)
 {
   // Process pipe error
-  if ((error != 0) && !Result()->error()) {
-    Result()->ErrorMessage = cmStrCat(
+  if ((error != 0) && !this->Result()->error()) {
+    this->Result()->ErrorMessage = cmStrCat(
       "Reading from stderr pipe failed with libuv error code ", error);
   }
   // Try finish
-  UVTryFinish();
+  this->UVTryFinish();
 }
 
 void cmUVReadOnlyProcess::UVTryFinish()
@@ -362,12 +369,13 @@ void cmUVReadOnlyProcess::UVTryFinish()
   // There still might be data in the pipes after the process has finished.
   // Therefore check if the process is finished AND all pipes are closed
   // before signaling the worker thread to continue.
-  if ((UVProcess_.get() != nullptr) || (UVPipeOut_.uv_pipe() != nullptr) ||
-      (UVPipeErr_.uv_pipe() != nullptr)) {
+  if ((this->UVProcess_.get() != nullptr) ||
+      (this->UVPipeOut_.uv_pipe() != nullptr) ||
+      (this->UVPipeErr_.uv_pipe() != nullptr)) {
     return;
   }
-  IsFinished_ = true;
-  FinishedCallback_();
+  this->IsFinished_ = true;
+  this->FinishedCallback_();
 }
 
 /**
@@ -385,7 +393,7 @@ public:
   /**
    * Set the internal thread
    */
-  void SetThread(std::thread&& aThread) { Thread_ = std::move(aThread); }
+  void SetThread(std::thread&& aThread) { this->Thread_ = std::move(aThread); }
 
   /**
    * Run an external process
@@ -414,13 +422,13 @@ private:
 
 cmWorkerPoolWorker::cmWorkerPoolWorker(uv_loop_t& uvLoop)
 {
-  Proc_.Request.init(uvLoop, &cmWorkerPoolWorker::UVProcessStart, this);
+  this->Proc_.Request.init(uvLoop, &cmWorkerPoolWorker::UVProcessStart, this);
 }
 
 cmWorkerPoolWorker::~cmWorkerPoolWorker()
 {
-  if (Thread_.joinable()) {
-    Thread_.join();
+  if (this->Thread_.joinable()) {
+    this->Thread_.join();
   }
 }
 
@@ -433,17 +441,17 @@ bool cmWorkerPoolWorker::RunProcess(cmWorkerPool::ProcessResultT& result,
   }
   // Create process instance
   {
-    std::lock_guard<std::mutex> lock(Proc_.Mutex);
-    Proc_.ROP = cm::make_unique<cmUVReadOnlyProcess>();
-    Proc_.ROP->setup(&result, true, command, workingDirectory);
+    std::lock_guard<std::mutex> lock(this->Proc_.Mutex);
+    this->Proc_.ROP = cm::make_unique<cmUVReadOnlyProcess>();
+    this->Proc_.ROP->setup(&result, true, command, workingDirectory);
   }
   // Send asynchronous process start request to libuv loop
-  Proc_.Request.send();
+  this->Proc_.Request.send();
   // Wait until the process has been finished and destroyed
   {
-    std::unique_lock<std::mutex> ulock(Proc_.Mutex);
-    while (Proc_.ROP) {
-      Proc_.Condition.wait(ulock);
+    std::unique_lock<std::mutex> ulock(this->Proc_.Mutex);
+    while (this->Proc_.ROP) {
+      this->Proc_.Condition.wait(ulock);
     }
   }
   return !result.error();
@@ -469,12 +477,13 @@ void cmWorkerPoolWorker::UVProcessStart(uv_async_t* handle)
 
 void cmWorkerPoolWorker::UVProcessFinished()
 {
-  std::lock_guard<std::mutex> lock(Proc_.Mutex);
-  if (Proc_.ROP && (Proc_.ROP->IsFinished() || !Proc_.ROP->IsStarted())) {
-    Proc_.ROP.reset();
+  std::lock_guard<std::mutex> lock(this->Proc_.Mutex);
+  if (this->Proc_.ROP &&
+      (this->Proc_.ROP->IsFinished() || !this->Proc_.ROP->IsStarted())) {
+    this->Proc_.ROP.reset();
   }
   // Notify idling thread
-  Proc_.Condition.notify_one();
+  this->Proc_.Condition.notify_one();
 }
 
 /**
@@ -539,19 +548,19 @@ public:
 
 void cmWorkerPool::ProcessResultT::reset()
 {
-  ExitStatus = 0;
-  TermSignal = 0;
-  if (!StdOut.empty()) {
-    StdOut.clear();
-    StdOut.shrink_to_fit();
+  this->ExitStatus = 0;
+  this->TermSignal = 0;
+  if (!this->StdOut.empty()) {
+    this->StdOut.clear();
+    this->StdOut.shrink_to_fit();
   }
-  if (!StdErr.empty()) {
-    StdErr.clear();
-    StdErr.shrink_to_fit();
+  if (!this->StdErr.empty()) {
+    this->StdErr.clear();
+    this->StdErr.shrink_to_fit();
   }
-  if (!ErrorMessage.empty()) {
-    ErrorMessage.clear();
-    ErrorMessage.shrink_to_fit();
+  if (!this->ErrorMessage.empty()) {
+    this->ErrorMessage.clear();
+    this->ErrorMessage.shrink_to_fit();
   }
 }
 
@@ -563,56 +572,58 @@ cmWorkerPoolInternal::cmWorkerPoolInternal(cmWorkerPool* pool)
 #ifdef CMAKE_UV_SIGNAL_HACK
   UVHackRAII = cm::make_unique<cmUVSignalHackRAII>();
 #endif
-  UVLoop = cm::make_unique<uv_loop_t>();
-  uv_loop_init(UVLoop.get());
+  this->UVLoop = cm::make_unique<uv_loop_t>();
+  uv_loop_init(this->UVLoop.get());
 }
 
 cmWorkerPoolInternal::~cmWorkerPoolInternal()
 {
-  uv_loop_close(UVLoop.get());
+  uv_loop_close(this->UVLoop.get());
 }
 
 bool cmWorkerPoolInternal::Process()
 {
   // Reset state flags
-  Processing = true;
-  Aborting = false;
+  this->Processing = true;
+  this->Aborting = false;
   // Initialize libuv asynchronous request
-  UVRequestBegin.init(*UVLoop, &cmWorkerPoolInternal::UVSlotBegin, this);
-  UVRequestEnd.init(*UVLoop, &cmWorkerPoolInternal::UVSlotEnd, this);
+  this->UVRequestBegin.init(*this->UVLoop, &cmWorkerPoolInternal::UVSlotBegin,
+                            this);
+  this->UVRequestEnd.init(*this->UVLoop, &cmWorkerPoolInternal::UVSlotEnd,
+                          this);
   // Send begin request
-  UVRequestBegin.send();
+  this->UVRequestBegin.send();
   // Run libuv loop
-  bool success = (uv_run(UVLoop.get(), UV_RUN_DEFAULT) == 0);
+  bool success = (uv_run(this->UVLoop.get(), UV_RUN_DEFAULT) == 0);
   // Update state flags
-  Processing = false;
-  Aborting = false;
+  this->Processing = false;
+  this->Aborting = false;
   return success;
 }
 
 void cmWorkerPoolInternal::Abort()
 {
   // Clear all jobs and set abort flag
-  std::lock_guard<std::mutex> guard(Mutex);
-  if (!Aborting) {
+  std::lock_guard<std::mutex> guard(this->Mutex);
+  if (!this->Aborting) {
     // Register abort and clear queue
-    Aborting = true;
-    Queue.clear();
-    Condition.notify_all();
+    this->Aborting = true;
+    this->Queue.clear();
+    this->Condition.notify_all();
   }
 }
 
 inline bool cmWorkerPoolInternal::PushJob(cmWorkerPool::JobHandleT&& jobHandle)
 {
-  std::lock_guard<std::mutex> guard(Mutex);
-  if (Aborting) {
+  std::lock_guard<std::mutex> guard(this->Mutex);
+  if (this->Aborting) {
     return false;
   }
   // Append the job to the queue
-  Queue.emplace_back(std::move(jobHandle));
+  this->Queue.emplace_back(std::move(jobHandle));
   // Notify an idle worker if there's one
-  if (WorkersIdle != 0) {
-    Condition.notify_one();
+  if (this->WorkersIdle != 0) {
+    this->Condition.notify_one();
   }
   // Return success
   return true;
@@ -652,79 +663,79 @@ void cmWorkerPoolInternal::UVSlotEnd(uv_async_t* handle)
 void cmWorkerPoolInternal::Work(unsigned int workerIndex)
 {
   cmWorkerPool::JobHandleT jobHandle;
-  std::unique_lock<std::mutex> uLock(Mutex);
+  std::unique_lock<std::mutex> uLock(this->Mutex);
   // Increment running workers count
-  ++WorkersRunning;
+  ++this->WorkersRunning;
   // Enter worker main loop
   while (true) {
     // Abort on request
-    if (Aborting) {
+    if (this->Aborting) {
       break;
     }
     // Wait for new jobs on the main CV
-    if (Queue.empty()) {
-      ++WorkersIdle;
-      Condition.wait(uLock);
-      --WorkersIdle;
+    if (this->Queue.empty()) {
+      ++this->WorkersIdle;
+      this->Condition.wait(uLock);
+      --this->WorkersIdle;
       continue;
     }
 
     // If there is a fence currently active or waiting,
     // sleep on the main CV and try again.
-    if (FenceProcessing) {
-      Condition.wait(uLock);
+    if (this->FenceProcessing) {
+      this->Condition.wait(uLock);
       continue;
     }
 
     // Pop next job from queue
-    jobHandle = std::move(Queue.front());
-    Queue.pop_front();
+    jobHandle = std::move(this->Queue.front());
+    this->Queue.pop_front();
 
     // Check for fence jobs
     bool raisedFence = false;
     if (jobHandle->IsFence()) {
-      FenceProcessing = true;
+      this->FenceProcessing = true;
       raisedFence = true;
       // Wait on the Fence CV until all pending jobs are done.
-      while (JobsProcessing != 0 && !Aborting) {
-        ConditionFence.wait(uLock);
+      while (this->JobsProcessing != 0 && !this->Aborting) {
+        this->ConditionFence.wait(uLock);
       }
       // When aborting, explicitly kick all threads alive once more.
-      if (Aborting) {
-        FenceProcessing = false;
-        Condition.notify_all();
+      if (this->Aborting) {
+        this->FenceProcessing = false;
+        this->Condition.notify_all();
         break;
       }
     }
 
     // Unlocked scope for job processing
-    ++JobsProcessing;
+    ++this->JobsProcessing;
     {
       uLock.unlock();
-      jobHandle->Work(Pool, workerIndex); // Process job
-      jobHandle.reset();                  // Destroy job
+      jobHandle->Work(this->Pool, workerIndex); // Process job
+      jobHandle.reset();                        // Destroy job
       uLock.lock();
     }
-    --JobsProcessing;
+    --this->JobsProcessing;
 
     // If this was the thread that entered fence processing
     // originally, notify all idling workers that the fence
     // is done.
     if (raisedFence) {
-      FenceProcessing = false;
-      Condition.notify_all();
+      this->FenceProcessing = false;
+      this->Condition.notify_all();
     }
     // If fence processing is still not done, notify the
     // the fencing worker when all active jobs are done.
-    if (FenceProcessing && JobsProcessing == 0) {
-      ConditionFence.notify_all();
+    if (this->FenceProcessing && this->JobsProcessing == 0) {
+      this->ConditionFence.notify_all();
     }
   }
 
   // Decrement running workers count
-  if (--WorkersRunning == 0) {
+  if (--this->WorkersRunning == 0) {
     // Last worker thread about to finish. Send libuv event.
-    UVRequestEnd.send();
+    this->UVRequestEnd.send();
   }
 }
 
@@ -735,7 +746,7 @@ bool cmWorkerPool::JobT::RunProcess(ProcessResultT& result,
                                     std::string const& workingDirectory)
 {
   // Get worker by index
-  auto* wrk = Pool_->Int_->Workers.at(WorkerIndex_).get();
+  auto* wrk = this->Pool_->Int_->Workers.at(this->WorkerIndex_).get();
   return wrk->RunProcess(result, command, workingDirectory);
 }
 
@@ -748,29 +759,29 @@ cmWorkerPool::~cmWorkerPool() = default;
 
 void cmWorkerPool::SetThreadCount(unsigned int threadCount)
 {
-  if (!Int_->Processing) {
-    ThreadCount_ = (threadCount > 0) ? threadCount : 1u;
+  if (!this->Int_->Processing) {
+    this->ThreadCount_ = (threadCount > 0) ? threadCount : 1u;
   }
 }
 
 bool cmWorkerPool::Process(void* userData)
 {
   // Setup user data
-  UserData_ = userData;
+  this->UserData_ = userData;
   // Run libuv loop
-  bool success = Int_->Process();
+  bool success = this->Int_->Process();
   // Clear user data
-  UserData_ = nullptr;
+  this->UserData_ = nullptr;
   // Return
   return success;
 }
 
 bool cmWorkerPool::PushJob(JobHandleT&& jobHandle)
 {
-  return Int_->PushJob(std::move(jobHandle));
+  return this->Int_->PushJob(std::move(jobHandle));
 }
 
 void cmWorkerPool::Abort()
 {
-  Int_->Abort();
+  this->Int_->Abort();
 }
diff --git a/Source/cmWorkerPool.h b/Source/cmWorkerPool.h
index 0fb6707244..9082d7fecf 100644
--- a/Source/cmWorkerPool.h
+++ b/Source/cmWorkerPool.h
@@ -28,7 +28,8 @@ public:
     void reset();
     bool error() const
     {
-      return (ExitStatus != 0) || (TermSignal != 0) || !ErrorMessage.empty();
+      return (this->ExitStatus != 0) || (this->TermSignal != 0) ||
+        !this->ErrorMessage.empty();
     }
 
     std::int64_t ExitStatus = 0;
@@ -60,7 +61,7 @@ public:
      * - no jobs later in the queue will be processed before this job was
      *   processed
      */
-    bool IsFence() const { return Fence_; }
+    bool IsFence() const { return this->Fence_; }
 
   protected:
     /**
@@ -80,13 +81,13 @@ public:
      * Get the worker pool.
      * Only valid during the JobT::Process() call!
      */
-    cmWorkerPool* Pool() const { return Pool_; }
+    cmWorkerPool* Pool() const { return this->Pool_; }
 
     /**
      * Get the user data.
      * Only valid during the JobT::Process() call!
      */
-    void* UserData() const { return Pool_->UserData(); };
+    void* UserData() const { return this->Pool_->UserData(); };
 
     /**
      * Get the worker index.
@@ -95,7 +96,7 @@ public:
      * Concurrently processing jobs will never have the same WorkerIndex().
      * Only valid during the JobT::Process() call!
      */
-    unsigned int WorkerIndex() const { return WorkerIndex_; }
+    unsigned int WorkerIndex() const { return this->WorkerIndex_; }
 
     /**
      * Run an external read only process.
@@ -111,8 +112,8 @@ public:
     //! Worker thread entry method.
     void Work(cmWorkerPool* pool, unsigned int workerIndex)
     {
-      Pool_ = pool;
-      WorkerIndex_ = workerIndex;
+      this->Pool_ = pool;
+      this->WorkerIndex_ = workerIndex;
       this->Process();
     }
 
@@ -150,7 +151,7 @@ public:
   {
   public:
     //! Does nothing
-    void Process() override { Pool()->Abort(); }
+    void Process() override { this->Pool()->Abort(); }
   };
 
 public:
@@ -161,7 +162,7 @@ public:
   /**
    * Number of worker threads.
    */
-  unsigned int ThreadCount() const { return ThreadCount_; }
+  unsigned int ThreadCount() const { return this->ThreadCount_; }
 
   /**
    * Set the number of worker threads.
@@ -184,7 +185,7 @@ public:
    *
    * Only valid during Process().
    */
-  void* UserData() const { return UserData_; }
+  void* UserData() const { return this->UserData_; }
 
   // -- Job processing interface
 
@@ -212,7 +213,7 @@ public:
   template <class T, typename... Args>
   bool EmplaceJob(Args&&... args)
   {
-    return PushJob(cm::make_unique<T>(std::forward<Args>(args)...));
+    return this->PushJob(cm::make_unique<T>(std::forward<Args>(args)...));
   }
 
 private:
diff --git a/Source/cmWorkingDirectory.h b/Source/cmWorkingDirectory.h
index c8adea980f..e593621471 100644
--- a/Source/cmWorkingDirectory.h
+++ b/Source/cmWorkingDirectory.h
@@ -26,7 +26,7 @@ public:
 
   bool SetDirectory(std::string const& newdir);
   void Pop();
-  bool Failed() const { return ResultCode != 0; }
+  bool Failed() const { return this->ResultCode != 0; }
 
   /** \return 0 if the last attempt to set the working directory was
    *          successful. If it failed, the value returned will be the
@@ -34,7 +34,7 @@ public:
    *          of the error code can be obtained by passing the result
    *          to \c std::strerror().
    */
-  int GetLastResult() const { return ResultCode; }
+  int GetLastResult() const { return this->ResultCode; }
 
   std::string const& GetOldDirectory() const { return this->OldDir; }
 
diff --git a/Source/cmXMLWriter.h b/Source/cmXMLWriter.h
index a16c4c8717..8a32377a18 100644
--- a/Source/cmXMLWriter.h
+++ b/Source/cmXMLWriter.h
@@ -140,9 +140,9 @@ public:
   cmXMLDocument(cmXMLWriter& xml)
     : xmlwr(xml)
   {
-    xmlwr.StartDocument();
+    this->xmlwr.StartDocument();
   }
-  ~cmXMLDocument() { xmlwr.EndDocument(); }
+  ~cmXMLDocument() { this->xmlwr.EndDocument(); }
   cmXMLDocument(const cmXMLDocument&) = delete;
   cmXMLDocument& operator=(const cmXMLDocument&) = delete;
 
@@ -157,19 +157,19 @@ public:
   cmXMLElement(cmXMLWriter& xml, const char* tag)
     : xmlwr(xml)
   {
-    xmlwr.StartElement(tag);
+    this->xmlwr.StartElement(tag);
   }
   cmXMLElement(cmXMLElement& par, const char* tag)
     : xmlwr(par.xmlwr)
   {
-    xmlwr.StartElement(tag);
+    this->xmlwr.StartElement(tag);
   }
   cmXMLElement(cmXMLDocument& doc, const char* tag)
     : xmlwr(doc.xmlwr)
   {
-    xmlwr.StartElement(tag);
+    this->xmlwr.StartElement(tag);
   }
-  ~cmXMLElement() { xmlwr.EndElement(); }
+  ~cmXMLElement() { this->xmlwr.EndElement(); }
 
   cmXMLElement(const cmXMLElement&) = delete;
   cmXMLElement& operator=(const cmXMLElement&) = delete;
@@ -177,20 +177,20 @@ public:
   template <typename T>
   cmXMLElement& Attribute(const char* name, T const& value)
   {
-    xmlwr.Attribute(name, value);
+    this->xmlwr.Attribute(name, value);
     return *this;
   }
   template <typename T>
   void Content(T const& content)
   {
-    xmlwr.Content(content);
+    this->xmlwr.Content(content);
   }
   template <typename T>
   void Element(std::string const& name, T const& value)
   {
-    xmlwr.Element(name, value);
+    this->xmlwr.Element(name, value);
   }
-  void Comment(const char* comment) { xmlwr.Comment(comment); }
+  void Comment(const char* comment) { this->xmlwr.Comment(comment); }
 
 private:
   cmXMLWriter& xmlwr;
diff --git a/Source/cm_codecvt.cxx b/Source/cm_codecvt.cxx
index 122e02283c..15f83e0f78 100644
--- a/Source/cm_codecvt.cxx
+++ b/Source/cm_codecvt.cxx
@@ -35,7 +35,7 @@ codecvt::codecvt(Encoding e)
     case codecvt::None:
     // No encoding
     default:
-      m_noconv = true;
+      this->m_noconv = true;
   }
 }
 
@@ -43,7 +43,7 @@ codecvt::~codecvt() = default;
 
 bool codecvt::do_always_noconv() const throw()
 {
-  return m_noconv;
+  return this->m_noconv;
 }
 
 std::codecvt_base::result codecvt::do_out(mbstate_t& state, const char* from,
@@ -53,7 +53,7 @@ std::codecvt_base::result codecvt::do_out(mbstate_t& state, const char* from,
 {
   from_next = from;
   to_next = to;
-  if (m_noconv) {
+  if (this->m_noconv) {
     return std::codecvt_base::noconv;
   }
 #if defined(_WIN32)
@@ -130,7 +130,7 @@ std::codecvt_base::result codecvt::do_unshift(mbstate_t& state, char* to,
                                               char*& to_next) const
 {
   to_next = to;
-  if (m_noconv) {
+  if (this->m_noconv) {
     return std::codecvt_base::noconv;
   }
 #if defined(_WIN32)
diff --git a/Source/cmcmd.cxx b/Source/cmcmd.cxx
index 73fbfb657f..4c0fbeb530 100644
--- a/Source/cmcmd.cxx
+++ b/Source/cmcmd.cxx
@@ -2227,7 +2227,7 @@ int cmVSLink::Link()
     if (this->Verbose) {
       std::cout << "Visual Studio Incremental Link with embedded manifests\n";
     }
-    return LinkIncremental();
+    return this->LinkIncremental();
   }
   if (this->Verbose) {
     if (!this->Incremental) {
@@ -2236,7 +2236,7 @@ int cmVSLink::Link()
       std::cout << "Visual Studio Incremental Link without manifests\n";
     }
   }
-  return LinkNonIncremental();
+  return this->LinkNonIncremental();
 }
 
 static bool mtRetIsUpdate(int mtRet)
diff --git a/Tests/CMakeLib/run_compile_commands.cxx b/Tests/CMakeLib/run_compile_commands.cxx
index 2c77accf13..0fd6cfbfd2 100644
--- a/Tests/CMakeLib/run_compile_commands.cxx
+++ b/Tests/CMakeLib/run_compile_commands.cxx
@@ -36,8 +36,8 @@ public:
 
   void Parse()
   {
-    NextNonWhitespace();
-    ParseTranslationUnits();
+    this->NextNonWhitespace();
+    this->ParseTranslationUnits();
   }
 
   const TranslationUnitsType& GetTranslationUnits()
@@ -49,51 +49,51 @@ private:
   void ParseTranslationUnits()
   {
     this->TranslationUnits = TranslationUnitsType();
-    ExpectOrDie('[', "at start of compile command file\n");
+    this->ExpectOrDie('[', "at start of compile command file\n");
     do {
-      ParseTranslationUnit();
+      this->ParseTranslationUnit();
       this->TranslationUnits.push_back(this->Command);
-    } while (Expect(','));
-    ExpectOrDie(']', "at end of array");
+    } while (this->Expect(','));
+    this->ExpectOrDie(']', "at end of array");
   }
 
   void ParseTranslationUnit()
   {
     this->Command = CommandType();
-    if (!Expect('{')) {
+    if (!this->Expect('{')) {
       return;
     }
-    if (Expect('}')) {
+    if (this->Expect('}')) {
       return;
     }
     do {
-      ParseString();
+      this->ParseString();
       std::string name = this->String;
-      ExpectOrDie(':', "between name and value");
-      ParseString();
+      this->ExpectOrDie(':', "between name and value");
+      this->ParseString();
       std::string value = this->String;
       this->Command[name] = value;
-    } while (Expect(','));
-    ExpectOrDie('}', "at end of object");
+    } while (this->Expect(','));
+    this->ExpectOrDie('}', "at end of object");
   }
 
   void ParseString()
   {
     this->String = "";
-    if (!Expect('"')) {
+    if (!this->Expect('"')) {
       return;
     }
-    while (!Expect('"')) {
-      Expect('\\');
-      this->String.append(1, C);
-      Next();
+    while (!this->Expect('"')) {
+      this->Expect('\\');
+      this->String.append(1, this->C);
+      this->Next();
     }
   }
 
   bool Expect(char c)
   {
     if (this->C == c) {
-      NextNonWhitespace();
+      this->NextNonWhitespace();
       return true;
     }
     return false;
@@ -101,23 +101,23 @@ private:
 
   void ExpectOrDie(char c, const std::string& message)
   {
-    if (!Expect(c)) {
-      ErrorExit(std::string("'") + c + "' expected " + message + ".");
+    if (!this->Expect(c)) {
+      this->ErrorExit(std::string("'") + c + "' expected " + message + ".");
     }
   }
 
   void NextNonWhitespace()
   {
     do {
-      Next();
-    } while (IsWhitespace());
+      this->Next();
+    } while (this->IsWhitespace());
   }
 
   void Next()
   {
-    this->C = char(Input.get());
+    this->C = char(this->Input.get());
     if (this->Input.bad()) {
-      ErrorExit("Unexpected end of file.");
+      this->ErrorExit("Unexpected end of file.");
     }
   }
 
diff --git a/Tests/CMakeLib/testCMExtMemory.cxx b/Tests/CMakeLib/testCMExtMemory.cxx
index 2aeaf7f84c..d8932cef1e 100644
--- a/Tests/CMakeLib/testCMExtMemory.cxx
+++ b/Tests/CMakeLib/testCMExtMemory.cxx
@@ -26,9 +26,9 @@ public:
     : value(v)
   {
   }
-  ~Wrapper() { delete value; }
+  ~Wrapper() { delete this->value; }
 
-  T* get() const { return value; }
+  T* get() const { return this->value; }
 
 private:
   T* value;
diff --git a/Utilities/cmjsoncpp/src/lib_json/json_reader.cpp b/Utilities/cmjsoncpp/src/lib_json/json_reader.cpp
index 6eeba0e65e..8362fc4cb9 100644
--- a/Utilities/cmjsoncpp/src/lib_json/json_reader.cpp
+++ b/Utilities/cmjsoncpp/src/lib_json/json_reader.cpp
@@ -2,74 +2,88 @@
 // Copyright (C) 2016 InfoTeCS JSC. All rights reserved.
 // Distributed under MIT license, or public domain if desired and
 // recognized in your jurisdiction.
-// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+// See file LICENSE for detail or copy at
+// http://jsoncpp.sourceforge.net/LICENSE
 
 #if !defined(JSON_IS_AMALGAMATION)
-#include <json/assertions.h>
-#include <json/reader.h>
-#include <json/value.h>
-#include "json_tool.h"
+#  include <json/assertions.h>
+#  include <json/reader.h>
+#  include <json/value.h>
+
+#  include "json_tool.h"
 #endif // if !defined(JSON_IS_AMALGAMATION)
-#include <utility>
-#include <stdio.h>
-#include <assert.h>
-#include <string.h>
 #include <istream>
-#include <sstream>
+#include <limits>
 #include <memory>
 #include <set>
-#include <limits>
+#include <sstream>
+#include <utility>
+
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
 
 #if defined(_MSC_VER)
-#if !defined(WINCE) && defined(__STDC_SECURE_LIB__) && _MSC_VER >= 1500 // VC++ 9.0 and above 
-#define snprintf sprintf_s
-#elif _MSC_VER >= 1900 // VC++ 14.0 and above
-#define snprintf std::snprintf
-#else
-#define snprintf _snprintf
-#endif
+#  if !defined(WINCE) && defined(__STDC_SECURE_LIB__) &&                      \
+    _MSC_VER >= 1500 // VC++ 9.0 and above
+#    define snprintf sprintf_s
+#  elif _MSC_VER >= 1900 // VC++ 14.0 and above
+#    define snprintf std::snprintf
+#  else
+#    define snprintf _snprintf
+#  endif
 #elif defined(__ANDROID__) || defined(__QNXNTO__)
-#define snprintf snprintf
+#  define snprintf snprintf
 #elif __cplusplus >= 201103L
-#if !defined(__MINGW32__) && !defined(__CYGWIN__)
-#define snprintf std::snprintf
-#endif
+#  if !defined(__MINGW32__) && !defined(__CYGWIN__)
+#    define snprintf std::snprintf
+#  endif
 #endif
 
 #if defined(__QNXNTO__)
-#define sscanf std::sscanf
+#  define sscanf std::sscanf
 #endif
 
 #if defined(_MSC_VER) && _MSC_VER >= 1400 // VC++ 8.0
 // Disable warning about strdup being deprecated.
-#pragma warning(disable : 4996)
+#  pragma warning(disable : 4996)
 #endif
 
-// Define JSONCPP_DEPRECATED_STACK_LIMIT as an appropriate integer at compile time to change the stack limit
+// Define JSONCPP_DEPRECATED_STACK_LIMIT as an appropriate integer at compile
+// time to change the stack limit
 #if !defined(JSONCPP_DEPRECATED_STACK_LIMIT)
-#define JSONCPP_DEPRECATED_STACK_LIMIT 1000
+#  define JSONCPP_DEPRECATED_STACK_LIMIT 1000
 #endif
 
-static size_t const stackLimit_g = JSONCPP_DEPRECATED_STACK_LIMIT; // see readValue()
+static size_t const stackLimit_g =
+  JSONCPP_DEPRECATED_STACK_LIMIT; // see readValue()
 
 namespace Json {
 
 #if __cplusplus >= 201103L || (defined(_CPPLIB_VER) && _CPPLIB_VER >= 520)
 typedef std::unique_ptr<CharReader> CharReaderPtr;
 #else
-typedef std::auto_ptr<CharReader>   CharReaderPtr;
+typedef std::auto_ptr<CharReader> CharReaderPtr;
 #endif
 
 // Implementation of class Features
 // ////////////////////////////////
 
 Features::Features()
-    : allowComments_(true), strictRoot_(false),
-      allowDroppedNullPlaceholders_(false), allowNumericKeys_(false) {}
+  : allowComments_(true)
+  , strictRoot_(false)
+  , allowDroppedNullPlaceholders_(false)
+  , allowNumericKeys_(false)
+{
+}
 
-Features Features::all() { return Features(); }
+Features Features::all()
+{
+  return Features();
+}
 
-Features Features::strictMode() {
+Features Features::strictMode()
+{
   Features features;
   features.allowComments_ = false;
   features.strictRoot_ = true;
@@ -81,7 +95,8 @@ Features Features::strictMode() {
 // Implementation of class Reader
 // ////////////////////////////////
 
-bool Reader::containsNewLine(Reader::Location begin, Reader::Location end) {
+bool Reader::containsNewLine(Reader::Location begin, Reader::Location end)
+{
   for (; begin < end; ++begin)
     if (*begin == '\n' || *begin == '\r')
       return true;
@@ -92,24 +107,44 @@ bool Reader::containsNewLine(Reader::Location begin, Reader::Location end) {
 // //////////////////////////////////////////////////////////////////
 
 Reader::Reader()
-    : errors_(), document_(), begin_(), end_(), current_(), lastValueEnd_(),
-      lastValue_(), commentsBefore_(), features_(Features::all()),
-      collectComments_() {}
+  : errors_()
+  , document_()
+  , begin_()
+  , end_()
+  , current_()
+  , lastValueEnd_()
+  , lastValue_()
+  , commentsBefore_()
+  , features_(Features::all())
+  , collectComments_()
+{
+}
 
 Reader::Reader(const Features& features)
-    : errors_(), document_(), begin_(), end_(), current_(), lastValueEnd_(),
-      lastValue_(), commentsBefore_(), features_(features), collectComments_() {
+  : errors_()
+  , document_()
+  , begin_()
+  , end_()
+  , current_()
+  , lastValueEnd_()
+  , lastValue_()
+  , commentsBefore_()
+  , features_(features)
+  , collectComments_()
+{
 }
 
-bool
-Reader::parse(const std::string& document, Value& root, bool collectComments) {
-  document_.assign(document.begin(), document.end());
-  const char* begin = document_.c_str();
-  const char* end = begin + document_.length();
-  return parse(begin, end, root, collectComments);
+bool Reader::parse(const std::string& document, Value& root,
+                   bool collectComments)
+{
+  this->document_.assign(document.begin(), document.end());
+  const char* begin = this->document_.c_str();
+  const char* end = begin + this->document_.length();
+  return this->parse(begin, end, root, collectComments);
 }
 
-bool Reader::parse(std::istream& sin, Value& root, bool collectComments) {
+bool Reader::parse(std::istream& sin, Value& root, bool collectComments)
+{
   // std::istream_iterator<char> begin(sin);
   // std::istream_iterator<char> end;
   // Those would allow streamed input from a file, if parse() were a
@@ -119,257 +154,263 @@ bool Reader::parse(std::istream& sin, Value& root, bool collectComments) {
   // create an extra copy.
   JSONCPP_STRING doc;
   std::getline(sin, doc, (char)EOF);
-  return parse(doc.data(), doc.data() + doc.size(), root, collectComments);
+  return this->parse(doc.data(), doc.data() + doc.size(), root,
+                     collectComments);
 }
 
-bool Reader::parse(const char* beginDoc,
-                   const char* endDoc,
-                   Value& root,
-                   bool collectComments) {
-  if (!features_.allowComments_) {
+bool Reader::parse(const char* beginDoc, const char* endDoc, Value& root,
+                   bool collectComments)
+{
+  if (!this->features_.allowComments_) {
     collectComments = false;
   }
 
-  begin_ = beginDoc;
-  end_ = endDoc;
-  collectComments_ = collectComments;
-  current_ = begin_;
-  lastValueEnd_ = 0;
-  lastValue_ = 0;
-  commentsBefore_.clear();
-  errors_.clear();
-  while (!nodes_.empty())
-    nodes_.pop();
-  nodes_.push(&root);
-
-  bool successful = readValue();
+  this->begin_ = beginDoc;
+  this->end_ = endDoc;
+  this->collectComments_ = collectComments;
+  this->current_ = this->begin_;
+  this->lastValueEnd_ = 0;
+  this->lastValue_ = 0;
+  this->commentsBefore_.clear();
+  this->errors_.clear();
+  while (!this->nodes_.empty())
+    this->nodes_.pop();
+  this->nodes_.push(&root);
+
+  bool successful = this->readValue();
   Token token;
-  skipCommentTokens(token);
-  if (collectComments_ && !commentsBefore_.empty())
-    root.setComment(commentsBefore_, commentAfter);
-  if (features_.strictRoot_) {
+  this->skipCommentTokens(token);
+  if (this->collectComments_ && !this->commentsBefore_.empty())
+    root.setComment(this->commentsBefore_, commentAfter);
+  if (this->features_.strictRoot_) {
     if (!root.isArray() && !root.isObject()) {
-      // Set error location to start of doc, ideally should be first token found
-      // in doc
+      // Set error location to start of doc, ideally should be first token
+      // found in doc
       token.type_ = tokenError;
       token.start_ = beginDoc;
       token.end_ = endDoc;
-      addError(
-          "A valid JSON document must be either an array or an object value.",
-          token);
+      this->addError(
+        "A valid JSON document must be either an array or an object value.",
+        token);
       return false;
     }
   }
   return successful;
 }
 
-bool Reader::readValue() {
+bool Reader::readValue()
+{
   // readValue() may call itself only if it calls readObject() or ReadArray().
-  // These methods execute nodes_.push() just before and nodes_.pop)() just after calling readValue(). 
-  // parse() executes one nodes_.push(), so > instead of >=.
-  if (nodes_.size() > stackLimit_g) throwRuntimeError("Exceeded stackLimit in readValue().");
+  // These methods execute nodes_.push() just before and nodes_.pop)() just
+  // after calling readValue(). parse() executes one nodes_.push(), so >
+  // instead of >=.
+  if (this->nodes_.size() > stackLimit_g)
+    throwRuntimeError("Exceeded stackLimit in readValue().");
 
   Token token;
-  skipCommentTokens(token);
+  this->skipCommentTokens(token);
   bool successful = true;
 
-  if (collectComments_ && !commentsBefore_.empty()) {
-    currentValue().setComment(commentsBefore_, commentBefore);
-    commentsBefore_.clear();
+  if (this->collectComments_ && !this->commentsBefore_.empty()) {
+    this->currentValue().setComment(this->commentsBefore_, commentBefore);
+    this->commentsBefore_.clear();
   }
 
   switch (token.type_) {
-  case tokenObjectBegin:
-    successful = readObject(token);
-    currentValue().setOffsetLimit(current_ - begin_);
-    break;
-  case tokenArrayBegin:
-    successful = readArray(token);
-    currentValue().setOffsetLimit(current_ - begin_);
-    break;
-  case tokenNumber:
-    successful = decodeNumber(token);
-    break;
-  case tokenString:
-    successful = decodeString(token);
-    break;
-  case tokenTrue:
-    {
-    Value v(true);
-    currentValue().swapPayload(v);
-    currentValue().setOffsetStart(token.start_ - begin_);
-    currentValue().setOffsetLimit(token.end_ - begin_);
-    }
-    break;
-  case tokenFalse:
-    {
-    Value v(false);
-    currentValue().swapPayload(v);
-    currentValue().setOffsetStart(token.start_ - begin_);
-    currentValue().setOffsetLimit(token.end_ - begin_);
-    }
-    break;
-  case tokenNull:
-    {
-    Value v;
-    currentValue().swapPayload(v);
-    currentValue().setOffsetStart(token.start_ - begin_);
-    currentValue().setOffsetLimit(token.end_ - begin_);
-    }
-    break;
-  case tokenArraySeparator:
-  case tokenObjectEnd:
-  case tokenArrayEnd:
-    if (features_.allowDroppedNullPlaceholders_) {
-      // "Un-read" the current token and mark the current value as a null
-      // token.
-      current_--;
-      Value v;
-      currentValue().swapPayload(v);
-      currentValue().setOffsetStart(current_ - begin_ - 1);
-      currentValue().setOffsetLimit(current_ - begin_);
+    case tokenObjectBegin:
+      successful = this->readObject(token);
+      this->currentValue().setOffsetLimit(this->current_ - this->begin_);
+      break;
+    case tokenArrayBegin:
+      successful = this->readArray(token);
+      this->currentValue().setOffsetLimit(this->current_ - this->begin_);
+      break;
+    case tokenNumber:
+      successful = this->decodeNumber(token);
       break;
-    } // Else, fall through...
-  default:
-    currentValue().setOffsetStart(token.start_ - begin_);
-    currentValue().setOffsetLimit(token.end_ - begin_);
-    return addError("Syntax error: value, object or array expected.", token);
+    case tokenString:
+      successful = this->decodeString(token);
+      break;
+    case tokenTrue: {
+      Value v(true);
+      this->currentValue().swapPayload(v);
+      this->currentValue().setOffsetStart(token.start_ - this->begin_);
+      this->currentValue().setOffsetLimit(token.end_ - this->begin_);
+    } break;
+    case tokenFalse: {
+      Value v(false);
+      this->currentValue().swapPayload(v);
+      this->currentValue().setOffsetStart(token.start_ - this->begin_);
+      this->currentValue().setOffsetLimit(token.end_ - this->begin_);
+    } break;
+    case tokenNull: {
+      Value v;
+      this->currentValue().swapPayload(v);
+      this->currentValue().setOffsetStart(token.start_ - this->begin_);
+      this->currentValue().setOffsetLimit(token.end_ - this->begin_);
+    } break;
+    case tokenArraySeparator:
+    case tokenObjectEnd:
+    case tokenArrayEnd:
+      if (this->features_.allowDroppedNullPlaceholders_) {
+        // "Un-read" the current token and mark the current value as a null
+        // token.
+        this->current_--;
+        Value v;
+        this->currentValue().swapPayload(v);
+        this->currentValue().setOffsetStart(this->current_ - this->begin_ - 1);
+        this->currentValue().setOffsetLimit(this->current_ - this->begin_);
+        break;
+      } // Else, fall through...
+    default:
+      this->currentValue().setOffsetStart(token.start_ - this->begin_);
+      this->currentValue().setOffsetLimit(token.end_ - this->begin_);
+      return this->addError("Syntax error: value, object or array expected.",
+                            token);
   }
 
-  if (collectComments_) {
-    lastValueEnd_ = current_;
-    lastValue_ = &currentValue();
+  if (this->collectComments_) {
+    this->lastValueEnd_ = this->current_;
+    this->lastValue_ = &this->currentValue();
   }
 
   return successful;
 }
 
-void Reader::skipCommentTokens(Token& token) {
-  if (features_.allowComments_) {
+void Reader::skipCommentTokens(Token& token)
+{
+  if (this->features_.allowComments_) {
     do {
-      readToken(token);
+      this->readToken(token);
     } while (token.type_ == tokenComment);
   } else {
-    readToken(token);
+    this->readToken(token);
   }
 }
 
-bool Reader::readToken(Token& token) {
-  skipSpaces();
-  token.start_ = current_;
-  Char c = getNextChar();
+bool Reader::readToken(Token& token)
+{
+  this->skipSpaces();
+  token.start_ = this->current_;
+  Char c = this->getNextChar();
   bool ok = true;
   switch (c) {
-  case '{':
-    token.type_ = tokenObjectBegin;
-    break;
-  case '}':
-    token.type_ = tokenObjectEnd;
-    break;
-  case '[':
-    token.type_ = tokenArrayBegin;
-    break;
-  case ']':
-    token.type_ = tokenArrayEnd;
-    break;
-  case '"':
-    token.type_ = tokenString;
-    ok = readString();
-    break;
-  case '/':
-    token.type_ = tokenComment;
-    ok = readComment();
-    break;
-  case '0':
-  case '1':
-  case '2':
-  case '3':
-  case '4':
-  case '5':
-  case '6':
-  case '7':
-  case '8':
-  case '9':
-  case '-':
-    token.type_ = tokenNumber;
-    readNumber();
-    break;
-  case 't':
-    token.type_ = tokenTrue;
-    ok = match("rue", 3);
-    break;
-  case 'f':
-    token.type_ = tokenFalse;
-    ok = match("alse", 4);
-    break;
-  case 'n':
-    token.type_ = tokenNull;
-    ok = match("ull", 3);
-    break;
-  case ',':
-    token.type_ = tokenArraySeparator;
-    break;
-  case ':':
-    token.type_ = tokenMemberSeparator;
-    break;
-  case 0:
-    token.type_ = tokenEndOfStream;
-    break;
-  default:
-    ok = false;
-    break;
+    case '{':
+      token.type_ = tokenObjectBegin;
+      break;
+    case '}':
+      token.type_ = tokenObjectEnd;
+      break;
+    case '[':
+      token.type_ = tokenArrayBegin;
+      break;
+    case ']':
+      token.type_ = tokenArrayEnd;
+      break;
+    case '"':
+      token.type_ = tokenString;
+      ok = this->readString();
+      break;
+    case '/':
+      token.type_ = tokenComment;
+      ok = this->readComment();
+      break;
+    case '0':
+    case '1':
+    case '2':
+    case '3':
+    case '4':
+    case '5':
+    case '6':
+    case '7':
+    case '8':
+    case '9':
+    case '-':
+      token.type_ = tokenNumber;
+      this->readNumber();
+      break;
+    case 't':
+      token.type_ = tokenTrue;
+      ok = this->match("rue", 3);
+      break;
+    case 'f':
+      token.type_ = tokenFalse;
+      ok = this->match("alse", 4);
+      break;
+    case 'n':
+      token.type_ = tokenNull;
+      ok = this->match("ull", 3);
+      break;
+    case ',':
+      token.type_ = tokenArraySeparator;
+      break;
+    case ':':
+      token.type_ = tokenMemberSeparator;
+      break;
+    case 0:
+      token.type_ = tokenEndOfStream;
+      break;
+    default:
+      ok = false;
+      break;
   }
   if (!ok)
     token.type_ = tokenError;
-  token.end_ = current_;
+  token.end_ = this->current_;
   return true;
 }
 
-void Reader::skipSpaces() {
-  while (current_ != end_) {
-    Char c = *current_;
+void Reader::skipSpaces()
+{
+  while (this->current_ != this->end_) {
+    Char c = *this->current_;
     if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
-      ++current_;
+      ++this->current_;
     else
       break;
   }
 }
 
-bool Reader::match(Location pattern, int patternLength) {
-  if (end_ - current_ < patternLength)
+bool Reader::match(Location pattern, int patternLength)
+{
+  if (this->end_ - this->current_ < patternLength)
     return false;
   int index = patternLength;
   while (index--)
-    if (current_[index] != pattern[index])
+    if (this->current_[index] != pattern[index])
       return false;
-  current_ += patternLength;
+  this->current_ += patternLength;
   return true;
 }
 
-bool Reader::readComment() {
-  Location commentBegin = current_ - 1;
-  Char c = getNextChar();
+bool Reader::readComment()
+{
+  Location commentBegin = this->current_ - 1;
+  Char c = this->getNextChar();
   bool successful = false;
   if (c == '*')
-    successful = readCStyleComment();
+    successful = this->readCStyleComment();
   else if (c == '/')
-    successful = readCppStyleComment();
+    successful = this->readCppStyleComment();
   if (!successful)
     return false;
 
-  if (collectComments_) {
+  if (this->collectComments_) {
     CommentPlacement placement = commentBefore;
-    if (lastValueEnd_ && !containsNewLine(lastValueEnd_, commentBegin)) {
-      if (c != '*' || !containsNewLine(commentBegin, current_))
+    if (this->lastValueEnd_ &&
+        !containsNewLine(this->lastValueEnd_, commentBegin)) {
+      if (c != '*' || !containsNewLine(commentBegin, this->current_))
         placement = commentAfterOnSameLine;
     }
 
-    addComment(commentBegin, current_, placement);
+    this->addComment(commentBegin, this->current_, placement);
   }
   return true;
 }
 
-JSONCPP_STRING Reader::normalizeEOL(Reader::Location begin, Reader::Location end) {
+JSONCPP_STRING Reader::normalizeEOL(Reader::Location begin,
+                                    Reader::Location end)
+{
   JSONCPP_STRING normalized;
   normalized.reserve(static_cast<size_t>(end - begin));
   Reader::Location current = begin;
@@ -377,8 +418,8 @@ JSONCPP_STRING Reader::normalizeEOL(Reader::Location begin, Reader::Location end
     char c = *current++;
     if (c == '\r') {
       if (current != end && *current == '\n')
-         // convert dos EOL
-         ++current;
+        // convert dos EOL
+        ++current;
       // convert Mac EOL
       normalized += '\n';
     } else {
@@ -388,36 +429,39 @@ JSONCPP_STRING Reader::normalizeEOL(Reader::Location begin, Reader::Location end
   return normalized;
 }
 
-void
-Reader::addComment(Location begin, Location end, CommentPlacement placement) {
-  assert(collectComments_);
+void Reader::addComment(Location begin, Location end,
+                        CommentPlacement placement)
+{
+  assert(this->collectComments_);
   const JSONCPP_STRING& normalized = normalizeEOL(begin, end);
   if (placement == commentAfterOnSameLine) {
-    assert(lastValue_ != 0);
-    lastValue_->setComment(normalized, placement);
+    assert(this->lastValue_ != 0);
+    this->lastValue_->setComment(normalized, placement);
   } else {
-    commentsBefore_ += normalized;
+    this->commentsBefore_ += normalized;
   }
 }
 
-bool Reader::readCStyleComment() {
-  while ((current_ + 1) < end_) {
-    Char c = getNextChar();
-    if (c == '*' && *current_ == '/')
+bool Reader::readCStyleComment()
+{
+  while ((this->current_ + 1) < this->end_) {
+    Char c = this->getNextChar();
+    if (c == '*' && *this->current_ == '/')
       break;
   }
-  return getNextChar() == '/';
+  return this->getNextChar() == '/';
 }
 
-bool Reader::readCppStyleComment() {
-  while (current_ != end_) {
-    Char c = getNextChar();
+bool Reader::readCppStyleComment()
+{
+  while (this->current_ != this->end_) {
+    Char c = this->getNextChar();
     if (c == '\n')
       break;
     if (c == '\r') {
       // Consume DOS EOL. It will be normalized in addComment.
-      if (current_ != end_ && *current_ == '\n')
-        getNextChar();
+      if (this->current_ != this->end_ && *this->current_ == '\n')
+        this->getNextChar();
       // Break on Moc OS 9 EOL.
       break;
     }
@@ -425,127 +469,132 @@ bool Reader::readCppStyleComment() {
   return true;
 }
 
-void Reader::readNumber() {
-  const char *p = current_;
+void Reader::readNumber()
+{
+  const char* p = this->current_;
   char c = '0'; // stopgap for already consumed character
   // integral part
   while (c >= '0' && c <= '9')
-    c = (current_ = p) < end_ ? *p++ : '\0';
+    c = (this->current_ = p) < this->end_ ? *p++ : '\0';
   // fractional part
   if (c == '.') {
-    c = (current_ = p) < end_ ? *p++ : '\0';
+    c = (this->current_ = p) < this->end_ ? *p++ : '\0';
     while (c >= '0' && c <= '9')
-      c = (current_ = p) < end_ ? *p++ : '\0';
+      c = (this->current_ = p) < this->end_ ? *p++ : '\0';
   }
   // exponential part
   if (c == 'e' || c == 'E') {
-    c = (current_ = p) < end_ ? *p++ : '\0';
+    c = (this->current_ = p) < this->end_ ? *p++ : '\0';
     if (c == '+' || c == '-')
-      c = (current_ = p) < end_ ? *p++ : '\0';
+      c = (this->current_ = p) < this->end_ ? *p++ : '\0';
     while (c >= '0' && c <= '9')
-      c = (current_ = p) < end_ ? *p++ : '\0';
+      c = (this->current_ = p) < this->end_ ? *p++ : '\0';
   }
 }
 
-bool Reader::readString() {
+bool Reader::readString()
+{
   Char c = '\0';
-  while (current_ != end_) {
-    c = getNextChar();
+  while (this->current_ != this->end_) {
+    c = this->getNextChar();
     if (c == '\\')
-      getNextChar();
+      this->getNextChar();
     else if (c == '"')
       break;
   }
   return c == '"';
 }
 
-bool Reader::readObject(Token& tokenStart) {
+bool Reader::readObject(Token& tokenStart)
+{
   Token tokenName;
   JSONCPP_STRING name;
   Value init(objectValue);
-  currentValue().swapPayload(init);
-  currentValue().setOffsetStart(tokenStart.start_ - begin_);
-  while (readToken(tokenName)) {
+  this->currentValue().swapPayload(init);
+  this->currentValue().setOffsetStart(tokenStart.start_ - this->begin_);
+  while (this->readToken(tokenName)) {
     bool initialTokenOk = true;
     while (tokenName.type_ == tokenComment && initialTokenOk)
-      initialTokenOk = readToken(tokenName);
+      initialTokenOk = this->readToken(tokenName);
     if (!initialTokenOk)
       break;
     if (tokenName.type_ == tokenObjectEnd && name.empty()) // empty object
       return true;
     name.clear();
     if (tokenName.type_ == tokenString) {
-      if (!decodeString(tokenName, name))
-        return recoverFromError(tokenObjectEnd);
-    } else if (tokenName.type_ == tokenNumber && features_.allowNumericKeys_) {
+      if (!this->decodeString(tokenName, name))
+        return this->recoverFromError(tokenObjectEnd);
+    } else if (tokenName.type_ == tokenNumber &&
+               this->features_.allowNumericKeys_) {
       Value numberName;
-      if (!decodeNumber(tokenName, numberName))
-        return recoverFromError(tokenObjectEnd);
+      if (!this->decodeNumber(tokenName, numberName))
+        return this->recoverFromError(tokenObjectEnd);
       name = JSONCPP_STRING(numberName.asCString());
     } else {
       break;
     }
 
     Token colon;
-    if (!readToken(colon) || colon.type_ != tokenMemberSeparator) {
-      return addErrorAndRecover(
-          "Missing ':' after object member name", colon, tokenObjectEnd);
+    if (!this->readToken(colon) || colon.type_ != tokenMemberSeparator) {
+      return this->addErrorAndRecover("Missing ':' after object member name",
+                                      colon, tokenObjectEnd);
     }
-    Value& value = currentValue()[name];
-    nodes_.push(&value);
-    bool ok = readValue();
-    nodes_.pop();
+    Value& value = this->currentValue()[name];
+    this->nodes_.push(&value);
+    bool ok = this->readValue();
+    this->nodes_.pop();
     if (!ok) // error already set
-      return recoverFromError(tokenObjectEnd);
+      return this->recoverFromError(tokenObjectEnd);
 
     Token comma;
-    if (!readToken(comma) ||
+    if (!this->readToken(comma) ||
         (comma.type_ != tokenObjectEnd && comma.type_ != tokenArraySeparator &&
          comma.type_ != tokenComment)) {
-      return addErrorAndRecover(
-          "Missing ',' or '}' in object declaration", comma, tokenObjectEnd);
+      return this->addErrorAndRecover(
+        "Missing ',' or '}' in object declaration", comma, tokenObjectEnd);
     }
     bool finalizeTokenOk = true;
     while (comma.type_ == tokenComment && finalizeTokenOk)
-      finalizeTokenOk = readToken(comma);
+      finalizeTokenOk = this->readToken(comma);
     if (comma.type_ == tokenObjectEnd)
       return true;
   }
-  return addErrorAndRecover(
-      "Missing '}' or object member name", tokenName, tokenObjectEnd);
+  return this->addErrorAndRecover("Missing '}' or object member name",
+                                  tokenName, tokenObjectEnd);
 }
 
-bool Reader::readArray(Token& tokenStart) {
+bool Reader::readArray(Token& tokenStart)
+{
   Value init(arrayValue);
-  currentValue().swapPayload(init);
-  currentValue().setOffsetStart(tokenStart.start_ - begin_);
-  skipSpaces();
-  if (current_ != end_ && *current_ == ']') // empty array
+  this->currentValue().swapPayload(init);
+  this->currentValue().setOffsetStart(tokenStart.start_ - this->begin_);
+  this->skipSpaces();
+  if (this->current_ != this->end_ && *this->current_ == ']') // empty array
   {
     Token endArray;
-    readToken(endArray);
+    this->readToken(endArray);
     return true;
   }
   int index = 0;
   for (;;) {
-    Value& value = currentValue()[index++];
-    nodes_.push(&value);
-    bool ok = readValue();
-    nodes_.pop();
+    Value& value = this->currentValue()[index++];
+    this->nodes_.push(&value);
+    bool ok = this->readValue();
+    this->nodes_.pop();
     if (!ok) // error already set
-      return recoverFromError(tokenArrayEnd);
+      return this->recoverFromError(tokenArrayEnd);
 
     Token token;
     // Accept Comment after last item in the array.
-    ok = readToken(token);
+    ok = this->readToken(token);
     while (token.type_ == tokenComment && ok) {
-      ok = readToken(token);
+      ok = this->readToken(token);
     }
     bool badTokenType =
-        (token.type_ != tokenArraySeparator && token.type_ != tokenArrayEnd);
+      (token.type_ != tokenArraySeparator && token.type_ != tokenArrayEnd);
     if (!ok || badTokenType) {
-      return addErrorAndRecover(
-          "Missing ',' or ']' in array declaration", token, tokenArrayEnd);
+      return this->addErrorAndRecover(
+        "Missing ',' or ']' in array declaration", token, tokenArrayEnd);
     }
     if (token.type_ == tokenArrayEnd)
       break;
@@ -553,17 +602,19 @@ bool Reader::readArray(Token& tokenStart) {
   return true;
 }
 
-bool Reader::decodeNumber(Token& token) {
+bool Reader::decodeNumber(Token& token)
+{
   Value decoded;
-  if (!decodeNumber(token, decoded))
+  if (!this->decodeNumber(token, decoded))
     return false;
-  currentValue().swapPayload(decoded);
-  currentValue().setOffsetStart(token.start_ - begin_);
-  currentValue().setOffsetLimit(token.end_ - begin_);
+  this->currentValue().swapPayload(decoded);
+  this->currentValue().setOffsetStart(token.start_ - this->begin_);
+  this->currentValue().setOffsetLimit(token.end_ - this->begin_);
   return true;
 }
 
-bool Reader::decodeNumber(Token& token, Value& decoded) {
+bool Reader::decodeNumber(Token& token, Value& decoded)
+{
   // Attempts to parse the number as an integer. If the number is
   // larger than the maximum supported value of an integer then
   // we decode the number as a double.
@@ -571,16 +622,17 @@ bool Reader::decodeNumber(Token& token, Value& decoded) {
   bool isNegative = *current == '-';
   if (isNegative)
     ++current;
-  // TODO: Help the compiler do the div and mod at compile time or get rid of them.
-  Value::LargestUInt maxIntegerValue =
-      isNegative ? Value::LargestUInt(Value::maxLargestInt) + 1
-                 : Value::maxLargestUInt;
+  // TODO: Help the compiler do the div and mod at compile time or get rid of
+  // them.
+  Value::LargestUInt maxIntegerValue = isNegative
+    ? Value::LargestUInt(Value::maxLargestInt) + 1
+    : Value::maxLargestUInt;
   Value::LargestUInt threshold = maxIntegerValue / 10;
   Value::LargestUInt value = 0;
   while (current < token.end_) {
     Char c = *current++;
     if (c < '0' || c > '9')
-      return decodeDouble(token, decoded);
+      return this->decodeDouble(token, decoded);
     Value::UInt digit(static_cast<Value::UInt>(c - '0'));
     if (value >= threshold) {
       // We've hit or exceeded the max value divided by 10 (rounded down). If
@@ -589,7 +641,7 @@ bool Reader::decodeNumber(Token& token, Value& decoded) {
       // Otherwise treat this number as a double to avoid overflow.
       if (value > threshold || current != token.end_ ||
           digit > maxIntegerValue % 10) {
-        return decodeDouble(token, decoded);
+        return this->decodeDouble(token, decoded);
       }
     }
     value = value * 10 + digit;
@@ -605,40 +657,44 @@ bool Reader::decodeNumber(Token& token, Value& decoded) {
   return true;
 }
 
-bool Reader::decodeDouble(Token& token) {
+bool Reader::decodeDouble(Token& token)
+{
   Value decoded;
-  if (!decodeDouble(token, decoded))
+  if (!this->decodeDouble(token, decoded))
     return false;
-  currentValue().swapPayload(decoded);
-  currentValue().setOffsetStart(token.start_ - begin_);
-  currentValue().setOffsetLimit(token.end_ - begin_);
+  this->currentValue().swapPayload(decoded);
+  this->currentValue().setOffsetStart(token.start_ - this->begin_);
+  this->currentValue().setOffsetLimit(token.end_ - this->begin_);
   return true;
 }
 
-bool Reader::decodeDouble(Token& token, Value& decoded) {
+bool Reader::decodeDouble(Token& token, Value& decoded)
+{
   double value = 0;
   JSONCPP_STRING buffer(token.start_, token.end_);
   JSONCPP_ISTRINGSTREAM is(buffer);
   if (!(is >> value))
-    return addError("'" + JSONCPP_STRING(token.start_, token.end_) +
-                        "' is not a number.",
-                    token);
+    return this->addError("'" + JSONCPP_STRING(token.start_, token.end_) +
+                            "' is not a number.",
+                          token);
   decoded = value;
   return true;
 }
 
-bool Reader::decodeString(Token& token) {
+bool Reader::decodeString(Token& token)
+{
   JSONCPP_STRING decoded_string;
-  if (!decodeString(token, decoded_string))
+  if (!this->decodeString(token, decoded_string))
     return false;
   Value decoded(decoded_string);
-  currentValue().swapPayload(decoded);
-  currentValue().setOffsetStart(token.start_ - begin_);
-  currentValue().setOffsetLimit(token.end_ - begin_);
+  this->currentValue().swapPayload(decoded);
+  this->currentValue().setOffsetStart(token.start_ - this->begin_);
+  this->currentValue().setOffsetLimit(token.end_ - this->begin_);
   return true;
 }
 
-bool Reader::decodeString(Token& token, JSONCPP_STRING& decoded) {
+bool Reader::decodeString(Token& token, JSONCPP_STRING& decoded)
+{
   decoded.reserve(static_cast<size_t>(token.end_ - token.start_ - 2));
   Location current = token.start_ + 1; // skip '"'
   Location end = token.end_ - 1;       // do not include '"'
@@ -648,41 +704,43 @@ bool Reader::decodeString(Token& token, JSONCPP_STRING& decoded) {
       break;
     else if (c == '\\') {
       if (current == end)
-        return addError("Empty escape sequence in string", token, current);
+        return this->addError("Empty escape sequence in string", token,
+                              current);
       Char escape = *current++;
       switch (escape) {
-      case '"':
-        decoded += '"';
-        break;
-      case '/':
-        decoded += '/';
-        break;
-      case '\\':
-        decoded += '\\';
-        break;
-      case 'b':
-        decoded += '\b';
-        break;
-      case 'f':
-        decoded += '\f';
-        break;
-      case 'n':
-        decoded += '\n';
-        break;
-      case 'r':
-        decoded += '\r';
-        break;
-      case 't':
-        decoded += '\t';
-        break;
-      case 'u': {
-        unsigned int unicode;
-        if (!decodeUnicodeCodePoint(token, current, end, unicode))
-          return false;
-        decoded += codePointToUTF8(unicode);
-      } break;
-      default:
-        return addError("Bad escape sequence in string", token, current);
+        case '"':
+          decoded += '"';
+          break;
+        case '/':
+          decoded += '/';
+          break;
+        case '\\':
+          decoded += '\\';
+          break;
+        case 'b':
+          decoded += '\b';
+          break;
+        case 'f':
+          decoded += '\f';
+          break;
+        case 'n':
+          decoded += '\n';
+          break;
+        case 'r':
+          decoded += '\r';
+          break;
+        case 't':
+          decoded += '\t';
+          break;
+        case 'u': {
+          unsigned int unicode;
+          if (!this->decodeUnicodeCodePoint(token, current, end, unicode))
+            return false;
+          decoded += codePointToUTF8(unicode);
+        } break;
+        default:
+          return this->addError("Bad escape sequence in string", token,
+                                current);
       }
     } else {
       decoded += c;
@@ -691,44 +749,43 @@ bool Reader::decodeString(Token& token, JSONCPP_STRING& decoded) {
   return true;
 }
 
-bool Reader::decodeUnicodeCodePoint(Token& token,
-                                    Location& current,
-                                    Location end,
-                                    unsigned int& unicode) {
+bool Reader::decodeUnicodeCodePoint(Token& token, Location& current,
+                                    Location end, unsigned int& unicode)
+{
 
-  if (!decodeUnicodeEscapeSequence(token, current, end, unicode))
+  if (!this->decodeUnicodeEscapeSequence(token, current, end, unicode))
     return false;
   if (unicode >= 0xD800 && unicode <= 0xDBFF) {
     // surrogate pairs
     if (end - current < 6)
-      return addError(
-          "additional six characters expected to parse unicode surrogate pair.",
-          token,
-          current);
+      return this->addError(
+        "additional six characters expected to parse unicode surrogate pair.",
+        token, current);
     unsigned int surrogatePair;
     if (*(current++) == '\\' && *(current++) == 'u') {
-      if (decodeUnicodeEscapeSequence(token, current, end, surrogatePair)) {
-        unicode = 0x10000 + ((unicode & 0x3FF) << 10) + (surrogatePair & 0x3FF);
+      if (this->decodeUnicodeEscapeSequence(token, current, end,
+                                            surrogatePair)) {
+        unicode =
+          0x10000 + ((unicode & 0x3FF) << 10) + (surrogatePair & 0x3FF);
       } else
         return false;
     } else
-      return addError("expecting another \\u token to begin the second half of "
-                      "a unicode surrogate pair",
-                      token,
-                      current);
+      return this->addError(
+        "expecting another \\u token to begin the second half of "
+        "a unicode surrogate pair",
+        token, current);
   }
   return true;
 }
 
-bool Reader::decodeUnicodeEscapeSequence(Token& token,
-                                         Location& current,
+bool Reader::decodeUnicodeEscapeSequence(Token& token, Location& current,
                                          Location end,
-                                         unsigned int& ret_unicode) {
+                                         unsigned int& ret_unicode)
+{
   if (end - current < 4)
-    return addError(
-        "Bad unicode escape sequence in string: four digits expected.",
-        token,
-        current);
+    return this->addError(
+      "Bad unicode escape sequence in string: four digits expected.", token,
+      current);
   int unicode = 0;
   for (int index = 0; index < 4; ++index) {
     Char c = *current++;
@@ -740,60 +797,65 @@ bool Reader::decodeUnicodeEscapeSequence(Token& token,
     else if (c >= 'A' && c <= 'F')
       unicode += c - 'A' + 10;
     else
-      return addError(
-          "Bad unicode escape sequence in string: hexadecimal digit expected.",
-          token,
-          current);
+      return this->addError(
+        "Bad unicode escape sequence in string: hexadecimal digit expected.",
+        token, current);
   }
   ret_unicode = static_cast<unsigned int>(unicode);
   return true;
 }
 
-bool
-Reader::addError(const JSONCPP_STRING& message, Token& token, Location extra) {
+bool Reader::addError(const JSONCPP_STRING& message, Token& token,
+                      Location extra)
+{
   ErrorInfo info;
   info.token_ = token;
   info.message_ = message;
   info.extra_ = extra;
-  errors_.push_back(info);
+  this->errors_.push_back(info);
   return false;
 }
 
-bool Reader::recoverFromError(TokenType skipUntilToken) {
-  size_t const errorCount = errors_.size();
+bool Reader::recoverFromError(TokenType skipUntilToken)
+{
+  size_t const errorCount = this->errors_.size();
   Token skip;
   for (;;) {
-    if (!readToken(skip))
-      errors_.resize(errorCount); // discard errors caused by recovery
+    if (!this->readToken(skip))
+      this->errors_.resize(errorCount); // discard errors caused by recovery
     if (skip.type_ == skipUntilToken || skip.type_ == tokenEndOfStream)
       break;
   }
-  errors_.resize(errorCount);
+  this->errors_.resize(errorCount);
   return false;
 }
 
-bool Reader::addErrorAndRecover(const JSONCPP_STRING& message,
-                                Token& token,
-                                TokenType skipUntilToken) {
-  addError(message, token);
-  return recoverFromError(skipUntilToken);
+bool Reader::addErrorAndRecover(const JSONCPP_STRING& message, Token& token,
+                                TokenType skipUntilToken)
+{
+  this->addError(message, token);
+  return this->recoverFromError(skipUntilToken);
 }
 
-Value& Reader::currentValue() { return *(nodes_.top()); }
+Value& Reader::currentValue()
+{
+  return *(this->nodes_.top());
+}
 
-Reader::Char Reader::getNextChar() {
-  if (current_ == end_)
+Reader::Char Reader::getNextChar()
+{
+  if (this->current_ == this->end_)
     return 0;
-  return *current_++;
+  return *this->current_++;
 }
 
-void Reader::getLocationLineAndColumn(Location location,
-                                      int& line,
-                                      int& column) const {
-  Location current = begin_;
+void Reader::getLocationLineAndColumn(Location location, int& line,
+                                      int& column) const
+{
+  Location current = this->begin_;
   Location lastLineStart = current;
   line = 0;
-  while (current < location && current != end_) {
+  while (current < location && current != this->end_) {
     Char c = *current++;
     if (c == '\r') {
       if (*current == '\n')
@@ -810,91 +872,96 @@ void Reader::getLocationLineAndColumn(Location location,
   ++line;
 }
 
-JSONCPP_STRING Reader::getLocationLineAndColumn(Location location) const {
+JSONCPP_STRING Reader::getLocationLineAndColumn(Location location) const
+{
   int line, column;
-  getLocationLineAndColumn(location, line, column);
+  this->getLocationLineAndColumn(location, line, column);
   char buffer[18 + 16 + 16 + 1];
   snprintf(buffer, sizeof(buffer), "Line %d, Column %d", line, column);
   return buffer;
 }
 
 // Deprecated. Preserved for backward compatibility
-JSONCPP_STRING Reader::getFormatedErrorMessages() const {
-  return getFormattedErrorMessages();
+JSONCPP_STRING Reader::getFormatedErrorMessages() const
+{
+  return this->getFormattedErrorMessages();
 }
 
-JSONCPP_STRING Reader::getFormattedErrorMessages() const {
+JSONCPP_STRING Reader::getFormattedErrorMessages() const
+{
   JSONCPP_STRING formattedMessage;
-  for (Errors::const_iterator itError = errors_.begin();
-       itError != errors_.end();
-       ++itError) {
+  for (Errors::const_iterator itError = this->errors_.begin();
+       itError != this->errors_.end(); ++itError) {
     const ErrorInfo& error = *itError;
     formattedMessage +=
-        "* " + getLocationLineAndColumn(error.token_.start_) + "\n";
+      "* " + this->getLocationLineAndColumn(error.token_.start_) + "\n";
     formattedMessage += "  " + error.message_ + "\n";
     if (error.extra_)
-      formattedMessage +=
-          "See " + getLocationLineAndColumn(error.extra_) + " for detail.\n";
+      formattedMessage += "See " +
+        this->getLocationLineAndColumn(error.extra_) + " for detail.\n";
   }
   return formattedMessage;
 }
 
-std::vector<Reader::StructuredError> Reader::getStructuredErrors() const {
+std::vector<Reader::StructuredError> Reader::getStructuredErrors() const
+{
   std::vector<Reader::StructuredError> allErrors;
-  for (Errors::const_iterator itError = errors_.begin();
-       itError != errors_.end();
-       ++itError) {
+  for (Errors::const_iterator itError = this->errors_.begin();
+       itError != this->errors_.end(); ++itError) {
     const ErrorInfo& error = *itError;
     Reader::StructuredError structured;
-    structured.offset_start = error.token_.start_ - begin_;
-    structured.offset_limit = error.token_.end_ - begin_;
+    structured.offset_start = error.token_.start_ - this->begin_;
+    structured.offset_limit = error.token_.end_ - this->begin_;
     structured.message = error.message_;
     allErrors.push_back(structured);
   }
   return allErrors;
 }
 
-bool Reader::pushError(const Value& value, const JSONCPP_STRING& message) {
-  ptrdiff_t const length = end_ - begin_;
-  if(value.getOffsetStart() > length
-    || value.getOffsetLimit() > length)
+bool Reader::pushError(const Value& value, const JSONCPP_STRING& message)
+{
+  ptrdiff_t const length = this->end_ - this->begin_;
+  if (value.getOffsetStart() > length || value.getOffsetLimit() > length)
     return false;
   Token token;
   token.type_ = tokenError;
-  token.start_ = begin_ + value.getOffsetStart();
-  token.end_ = end_ + value.getOffsetLimit();
+  token.start_ = this->begin_ + value.getOffsetStart();
+  token.end_ = this->end_ + value.getOffsetLimit();
   ErrorInfo info;
   info.token_ = token;
   info.message_ = message;
   info.extra_ = 0;
-  errors_.push_back(info);
+  this->errors_.push_back(info);
   return true;
 }
 
-bool Reader::pushError(const Value& value, const JSONCPP_STRING& message, const Value& extra) {
-  ptrdiff_t const length = end_ - begin_;
-  if(value.getOffsetStart() > length
-    || value.getOffsetLimit() > length
-    || extra.getOffsetLimit() > length)
+bool Reader::pushError(const Value& value, const JSONCPP_STRING& message,
+                       const Value& extra)
+{
+  ptrdiff_t const length = this->end_ - this->begin_;
+  if (value.getOffsetStart() > length || value.getOffsetLimit() > length ||
+      extra.getOffsetLimit() > length)
     return false;
   Token token;
   token.type_ = tokenError;
-  token.start_ = begin_ + value.getOffsetStart();
-  token.end_ = begin_ + value.getOffsetLimit();
+  token.start_ = this->begin_ + value.getOffsetStart();
+  token.end_ = this->begin_ + value.getOffsetLimit();
   ErrorInfo info;
   info.token_ = token;
   info.message_ = message;
-  info.extra_ = begin_ + extra.getOffsetStart();
-  errors_.push_back(info);
+  info.extra_ = this->begin_ + extra.getOffsetStart();
+  this->errors_.push_back(info);
   return true;
 }
 
-bool Reader::good() const {
-  return !errors_.size();
+bool Reader::good() const
+{
+  return !this->errors_.size();
 }
 
 // exact copy of Features
-class OurFeatures {
+class OurFeatures
+{
 public:
   static OurFeatures all();
   bool allowComments_;
@@ -906,43 +973,48 @@ public:
   bool rejectDupKeys_;
   bool allowSpecialFloats_;
   int stackLimit_;
-};  // OurFeatures
+}; // OurFeatures
 
 // exact copy of Implementation of class Features
 // ////////////////////////////////
 
-OurFeatures OurFeatures::all() { return OurFeatures(); }
+OurFeatures OurFeatures::all()
+{
+  return OurFeatures();
+}
 
 // Implementation of class Reader
 // ////////////////////////////////
 
 // exact copy of Reader, renamed to OurReader
-class OurReader {
+class OurReader
+{
 public:
   typedef char Char;
   typedef const Char* Location;
-  struct StructuredError {
+  struct StructuredError
+  {
     ptrdiff_t offset_start;
     ptrdiff_t offset_limit;
     JSONCPP_STRING message;
   };
 
   OurReader(OurFeatures const& features);
-  bool parse(const char* beginDoc,
-             const char* endDoc,
-             Value& root,
+  bool parse(const char* beginDoc, const char* endDoc, Value& root,
              bool collectComments = true);
   JSONCPP_STRING getFormattedErrorMessages() const;
   std::vector<StructuredError> getStructuredErrors() const;
   bool pushError(const Value& value, const JSONCPP_STRING& message);
-  bool pushError(const Value& value, const JSONCPP_STRING& message, const Value& extra);
+  bool pushError(const Value& value, const JSONCPP_STRING& message,
+                 const Value& extra);
   bool good() const;
 
 private:
-  OurReader(OurReader const&);  // no impl
-  void operator=(OurReader const&);  // no impl
+  OurReader(OurReader const&);      // no impl
+  void operator=(OurReader const&); // no impl
 
-  enum TokenType {
+  enum TokenType
+  {
     tokenEndOfStream = 0,
     tokenObjectBegin,
     tokenObjectEnd,
@@ -962,14 +1034,16 @@ private:
     tokenError
   };
 
-  class Token {
+  class Token
+  {
   public:
     TokenType type_;
     Location start_;
     Location end_;
   };
 
-  class ErrorInfo {
+  class ErrorInfo
+  {
   public:
     Token token_;
     JSONCPP_STRING message_;
@@ -996,24 +1070,20 @@ private:
   bool decodeString(Token& token, JSONCPP_STRING& decoded);
   bool decodeDouble(Token& token);
   bool decodeDouble(Token& token, Value& decoded);
-  bool decodeUnicodeCodePoint(Token& token,
-                              Location& current,
-                              Location end,
+  bool decodeUnicodeCodePoint(Token& token, Location& current, Location end,
                               unsigned int& unicode);
-  bool decodeUnicodeEscapeSequence(Token& token,
-                                   Location& current,
-                                   Location end,
-                                   unsigned int& unicode);
-  bool addError(const JSONCPP_STRING& message, Token& token, Location extra = 0);
+  bool decodeUnicodeEscapeSequence(Token& token, Location& current,
+                                   Location end, unsigned int& unicode);
+  bool addError(const JSONCPP_STRING& message, Token& token,
+                Location extra = 0);
   bool recoverFromError(TokenType skipUntilToken);
-  bool addErrorAndRecover(const JSONCPP_STRING& message,
-                          Token& token,
+  bool addErrorAndRecover(const JSONCPP_STRING& message, Token& token,
                           TokenType skipUntilToken);
   void skipUntilSpace();
   Value& currentValue();
   Char getNextChar();
-  void
-  getLocationLineAndColumn(Location location, int& line, int& column) const;
+  void getLocationLineAndColumn(Location location, int& line,
+                                int& column) const;
   JSONCPP_STRING getLocationLineAndColumn(Location location) const;
   void addComment(Location begin, Location end, CommentPlacement placement);
   void skipCommentTokens(Token& token);
@@ -1034,11 +1104,13 @@ private:
 
   OurFeatures const features_;
   bool collectComments_;
-};  // OurReader
+}; // OurReader
 
 // complete copy of Read impl, for OurReader
 
-bool OurReader::containsNewLine(OurReader::Location begin, OurReader::Location end) {
+bool OurReader::containsNewLine(OurReader::Location begin,
+                                OurReader::Location end)
+{
   for (; begin < end; ++begin)
     if (*begin == '\n' || *begin == '\r')
       return true;
@@ -1046,315 +1118,322 @@ bool OurReader::containsNewLine(OurReader::Location begin, OurReader::Location e
 }
 
 OurReader::OurReader(OurFeatures const& features)
-    : errors_(), document_(), begin_(), end_(), current_(), lastValueEnd_(),
-      lastValue_(), commentsBefore_(),
-      features_(features), collectComments_() {
+  : errors_()
+  , document_()
+  , begin_()
+  , end_()
+  , current_()
+  , lastValueEnd_()
+  , lastValue_()
+  , commentsBefore_()
+  , features_(features)
+  , collectComments_()
+{
 }
 
-bool OurReader::parse(const char* beginDoc,
-                   const char* endDoc,
-                   Value& root,
-                   bool collectComments) {
-  if (!features_.allowComments_) {
+bool OurReader::parse(const char* beginDoc, const char* endDoc, Value& root,
+                      bool collectComments)
+{
+  if (!this->features_.allowComments_) {
     collectComments = false;
   }
 
-  begin_ = beginDoc;
-  end_ = endDoc;
-  collectComments_ = collectComments;
-  current_ = begin_;
-  lastValueEnd_ = 0;
-  lastValue_ = 0;
-  commentsBefore_.clear();
-  errors_.clear();
-  while (!nodes_.empty())
-    nodes_.pop();
-  nodes_.push(&root);
-
-  bool successful = readValue();
+  this->begin_ = beginDoc;
+  this->end_ = endDoc;
+  this->collectComments_ = collectComments;
+  this->current_ = this->begin_;
+  this->lastValueEnd_ = 0;
+  this->lastValue_ = 0;
+  this->commentsBefore_.clear();
+  this->errors_.clear();
+  while (!this->nodes_.empty())
+    this->nodes_.pop();
+  this->nodes_.push(&root);
+
+  bool successful = this->readValue();
   Token token;
-  skipCommentTokens(token);
-  if (features_.failIfExtra_) {
-    if ((features_.strictRoot_ || token.type_ != tokenError) && token.type_ != tokenEndOfStream) {
-      addError("Extra non-whitespace after JSON value.", token);
+  this->skipCommentTokens(token);
+  if (this->features_.failIfExtra_) {
+    if ((this->features_.strictRoot_ || token.type_ != tokenError) &&
+        token.type_ != tokenEndOfStream) {
+      this->addError("Extra non-whitespace after JSON value.", token);
       return false;
     }
   }
-  if (collectComments_ && !commentsBefore_.empty())
-    root.setComment(commentsBefore_, commentAfter);
-  if (features_.strictRoot_) {
+  if (this->collectComments_ && !this->commentsBefore_.empty())
+    root.setComment(this->commentsBefore_, commentAfter);
+  if (this->features_.strictRoot_) {
     if (!root.isArray() && !root.isObject()) {
-      // Set error location to start of doc, ideally should be first token found
-      // in doc
+      // Set error location to start of doc, ideally should be first token
+      // found in doc
       token.type_ = tokenError;
       token.start_ = beginDoc;
       token.end_ = endDoc;
-      addError(
-          "A valid JSON document must be either an array or an object value.",
-          token);
+      this->addError(
+        "A valid JSON document must be either an array or an object value.",
+        token);
       return false;
     }
   }
   return successful;
 }
 
-bool OurReader::readValue() {
+bool OurReader::readValue()
+{
   //  To preserve the old behaviour we cast size_t to int.
-  if (static_cast<int>(nodes_.size()) > features_.stackLimit_) throwRuntimeError("Exceeded stackLimit in readValue().");
+  if (static_cast<int>(this->nodes_.size()) > this->features_.stackLimit_)
+    throwRuntimeError("Exceeded stackLimit in readValue().");
   Token token;
-  skipCommentTokens(token);
+  this->skipCommentTokens(token);
   bool successful = true;
 
-  if (collectComments_ && !commentsBefore_.empty()) {
-    currentValue().setComment(commentsBefore_, commentBefore);
-    commentsBefore_.clear();
+  if (this->collectComments_ && !this->commentsBefore_.empty()) {
+    this->currentValue().setComment(this->commentsBefore_, commentBefore);
+    this->commentsBefore_.clear();
   }
 
   switch (token.type_) {
-  case tokenObjectBegin:
-    successful = readObject(token);
-    currentValue().setOffsetLimit(current_ - begin_);
-    break;
-  case tokenArrayBegin:
-    successful = readArray(token);
-    currentValue().setOffsetLimit(current_ - begin_);
-    break;
-  case tokenNumber:
-    successful = decodeNumber(token);
-    break;
-  case tokenString:
-    successful = decodeString(token);
-    break;
-  case tokenTrue:
-    {
-    Value v(true);
-    currentValue().swapPayload(v);
-    currentValue().setOffsetStart(token.start_ - begin_);
-    currentValue().setOffsetLimit(token.end_ - begin_);
-    }
-    break;
-  case tokenFalse:
-    {
-    Value v(false);
-    currentValue().swapPayload(v);
-    currentValue().setOffsetStart(token.start_ - begin_);
-    currentValue().setOffsetLimit(token.end_ - begin_);
-    }
-    break;
-  case tokenNull:
-    {
-    Value v;
-    currentValue().swapPayload(v);
-    currentValue().setOffsetStart(token.start_ - begin_);
-    currentValue().setOffsetLimit(token.end_ - begin_);
-    }
-    break;
-  case tokenNaN:
-    {
-    Value v(std::numeric_limits<double>::quiet_NaN());
-    currentValue().swapPayload(v);
-    currentValue().setOffsetStart(token.start_ - begin_);
-    currentValue().setOffsetLimit(token.end_ - begin_);
-    }
-    break;
-  case tokenPosInf:
-    {
-    Value v(std::numeric_limits<double>::infinity());
-    currentValue().swapPayload(v);
-    currentValue().setOffsetStart(token.start_ - begin_);
-    currentValue().setOffsetLimit(token.end_ - begin_);
-    }
-    break;
-  case tokenNegInf:
-    {
-    Value v(-std::numeric_limits<double>::infinity());
-    currentValue().swapPayload(v);
-    currentValue().setOffsetStart(token.start_ - begin_);
-    currentValue().setOffsetLimit(token.end_ - begin_);
-    }
-    break;
-  case tokenArraySeparator:
-  case tokenObjectEnd:
-  case tokenArrayEnd:
-    if (features_.allowDroppedNullPlaceholders_) {
-      // "Un-read" the current token and mark the current value as a null
-      // token.
-      current_--;
-      Value v;
-      currentValue().swapPayload(v);
-      currentValue().setOffsetStart(current_ - begin_ - 1);
-      currentValue().setOffsetLimit(current_ - begin_);
+    case tokenObjectBegin:
+      successful = this->readObject(token);
+      this->currentValue().setOffsetLimit(this->current_ - this->begin_);
+      break;
+    case tokenArrayBegin:
+      successful = this->readArray(token);
+      this->currentValue().setOffsetLimit(this->current_ - this->begin_);
+      break;
+    case tokenNumber:
+      successful = this->decodeNumber(token);
       break;
-    } // else, fall through ...
-  default:
-    currentValue().setOffsetStart(token.start_ - begin_);
-    currentValue().setOffsetLimit(token.end_ - begin_);
-    return addError("Syntax error: value, object or array expected.", token);
+    case tokenString:
+      successful = this->decodeString(token);
+      break;
+    case tokenTrue: {
+      Value v(true);
+      this->currentValue().swapPayload(v);
+      this->currentValue().setOffsetStart(token.start_ - this->begin_);
+      this->currentValue().setOffsetLimit(token.end_ - this->begin_);
+    } break;
+    case tokenFalse: {
+      Value v(false);
+      this->currentValue().swapPayload(v);
+      this->currentValue().setOffsetStart(token.start_ - this->begin_);
+      this->currentValue().setOffsetLimit(token.end_ - this->begin_);
+    } break;
+    case tokenNull: {
+      Value v;
+      this->currentValue().swapPayload(v);
+      this->currentValue().setOffsetStart(token.start_ - this->begin_);
+      this->currentValue().setOffsetLimit(token.end_ - this->begin_);
+    } break;
+    case tokenNaN: {
+      Value v(std::numeric_limits<double>::quiet_NaN());
+      this->currentValue().swapPayload(v);
+      this->currentValue().setOffsetStart(token.start_ - this->begin_);
+      this->currentValue().setOffsetLimit(token.end_ - this->begin_);
+    } break;
+    case tokenPosInf: {
+      Value v(std::numeric_limits<double>::infinity());
+      this->currentValue().swapPayload(v);
+      this->currentValue().setOffsetStart(token.start_ - this->begin_);
+      this->currentValue().setOffsetLimit(token.end_ - this->begin_);
+    } break;
+    case tokenNegInf: {
+      Value v(-std::numeric_limits<double>::infinity());
+      this->currentValue().swapPayload(v);
+      this->currentValue().setOffsetStart(token.start_ - this->begin_);
+      this->currentValue().setOffsetLimit(token.end_ - this->begin_);
+    } break;
+    case tokenArraySeparator:
+    case tokenObjectEnd:
+    case tokenArrayEnd:
+      if (this->features_.allowDroppedNullPlaceholders_) {
+        // "Un-read" the current token and mark the current value as a null
+        // token.
+        this->current_--;
+        Value v;
+        this->currentValue().swapPayload(v);
+        this->currentValue().setOffsetStart(this->current_ - this->begin_ - 1);
+        this->currentValue().setOffsetLimit(this->current_ - this->begin_);
+        break;
+      } // else, fall through ...
+    default:
+      this->currentValue().setOffsetStart(token.start_ - this->begin_);
+      this->currentValue().setOffsetLimit(token.end_ - this->begin_);
+      return this->addError("Syntax error: value, object or array expected.",
+                            token);
   }
 
-  if (collectComments_) {
-    lastValueEnd_ = current_;
-    lastValue_ = &currentValue();
+  if (this->collectComments_) {
+    this->lastValueEnd_ = this->current_;
+    this->lastValue_ = &this->currentValue();
   }
 
   return successful;
 }
 
-void OurReader::skipCommentTokens(Token& token) {
-  if (features_.allowComments_) {
+void OurReader::skipCommentTokens(Token& token)
+{
+  if (this->features_.allowComments_) {
     do {
-      readToken(token);
+      this->readToken(token);
     } while (token.type_ == tokenComment);
   } else {
-    readToken(token);
+    this->readToken(token);
   }
 }
 
-bool OurReader::readToken(Token& token) {
-  skipSpaces();
-  token.start_ = current_;
-  Char c = getNextChar();
+bool OurReader::readToken(Token& token)
+{
+  this->skipSpaces();
+  token.start_ = this->current_;
+  Char c = this->getNextChar();
   bool ok = true;
   switch (c) {
-  case '{':
-    token.type_ = tokenObjectBegin;
-    break;
-  case '}':
-    token.type_ = tokenObjectEnd;
-    break;
-  case '[':
-    token.type_ = tokenArrayBegin;
-    break;
-  case ']':
-    token.type_ = tokenArrayEnd;
-    break;
-  case '"':
-    token.type_ = tokenString;
-    ok = readString();
-    break;
-  case '\'':
-    if (features_.allowSingleQuotes_) {
-    token.type_ = tokenString;
-    ok = readStringSingleQuote();
-    break;
-    } // else continue
-  case '/':
-    token.type_ = tokenComment;
-    ok = readComment();
-    break;
-  case '0':
-  case '1':
-  case '2':
-  case '3':
-  case '4':
-  case '5':
-  case '6':
-  case '7':
-  case '8':
-  case '9':
-    token.type_ = tokenNumber;
-    readNumber(false);
-    break;
-  case '-':
-    if (readNumber(true)) {
+    case '{':
+      token.type_ = tokenObjectBegin;
+      break;
+    case '}':
+      token.type_ = tokenObjectEnd;
+      break;
+    case '[':
+      token.type_ = tokenArrayBegin;
+      break;
+    case ']':
+      token.type_ = tokenArrayEnd;
+      break;
+    case '"':
+      token.type_ = tokenString;
+      ok = this->readString();
+      break;
+    case '\'':
+      if (this->features_.allowSingleQuotes_) {
+        token.type_ = tokenString;
+        ok = this->readStringSingleQuote();
+        break;
+      } // else continue
+    case '/':
+      token.type_ = tokenComment;
+      ok = this->readComment();
+      break;
+    case '0':
+    case '1':
+    case '2':
+    case '3':
+    case '4':
+    case '5':
+    case '6':
+    case '7':
+    case '8':
+    case '9':
       token.type_ = tokenNumber;
-    } else {
-      token.type_ = tokenNegInf;
-      ok = features_.allowSpecialFloats_ && match("nfinity", 7);
-    }
-    break;
-  case 't':
-    token.type_ = tokenTrue;
-    ok = match("rue", 3);
-    break;
-  case 'f':
-    token.type_ = tokenFalse;
-    ok = match("alse", 4);
-    break;
-  case 'n':
-    token.type_ = tokenNull;
-    ok = match("ull", 3);
-    break;
-  case 'N':
-    if (features_.allowSpecialFloats_) {
-      token.type_ = tokenNaN;
-      ok = match("aN", 2);
-    } else {
-      ok = false;
-    }
-    break;
-  case 'I':
-    if (features_.allowSpecialFloats_) {
-      token.type_ = tokenPosInf;
-      ok = match("nfinity", 7);
-    } else {
+      this->readNumber(false);
+      break;
+    case '-':
+      if (this->readNumber(true)) {
+        token.type_ = tokenNumber;
+      } else {
+        token.type_ = tokenNegInf;
+        ok = this->features_.allowSpecialFloats_ && this->match("nfinity", 7);
+      }
+      break;
+    case 't':
+      token.type_ = tokenTrue;
+      ok = this->match("rue", 3);
+      break;
+    case 'f':
+      token.type_ = tokenFalse;
+      ok = this->match("alse", 4);
+      break;
+    case 'n':
+      token.type_ = tokenNull;
+      ok = this->match("ull", 3);
+      break;
+    case 'N':
+      if (this->features_.allowSpecialFloats_) {
+        token.type_ = tokenNaN;
+        ok = this->match("aN", 2);
+      } else {
+        ok = false;
+      }
+      break;
+    case 'I':
+      if (this->features_.allowSpecialFloats_) {
+        token.type_ = tokenPosInf;
+        ok = this->match("nfinity", 7);
+      } else {
+        ok = false;
+      }
+      break;
+    case ',':
+      token.type_ = tokenArraySeparator;
+      break;
+    case ':':
+      token.type_ = tokenMemberSeparator;
+      break;
+    case 0:
+      token.type_ = tokenEndOfStream;
+      break;
+    default:
       ok = false;
-    }
-    break;
-  case ',':
-    token.type_ = tokenArraySeparator;
-    break;
-  case ':':
-    token.type_ = tokenMemberSeparator;
-    break;
-  case 0:
-    token.type_ = tokenEndOfStream;
-    break;
-  default:
-    ok = false;
-    break;
+      break;
   }
   if (!ok)
     token.type_ = tokenError;
-  token.end_ = current_;
+  token.end_ = this->current_;
   return true;
 }
 
-void OurReader::skipSpaces() {
-  while (current_ != end_) {
-    Char c = *current_;
+void OurReader::skipSpaces()
+{
+  while (this->current_ != this->end_) {
+    Char c = *this->current_;
     if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
-      ++current_;
+      ++this->current_;
     else
       break;
   }
 }
 
-bool OurReader::match(Location pattern, int patternLength) {
-  if (end_ - current_ < patternLength)
+bool OurReader::match(Location pattern, int patternLength)
+{
+  if (this->end_ - this->current_ < patternLength)
     return false;
   int index = patternLength;
   while (index--)
-    if (current_[index] != pattern[index])
+    if (this->current_[index] != pattern[index])
       return false;
-  current_ += patternLength;
+  this->current_ += patternLength;
   return true;
 }
 
-bool OurReader::readComment() {
-  Location commentBegin = current_ - 1;
-  Char c = getNextChar();
+bool OurReader::readComment()
+{
+  Location commentBegin = this->current_ - 1;
+  Char c = this->getNextChar();
   bool successful = false;
   if (c == '*')
-    successful = readCStyleComment();
+    successful = this->readCStyleComment();
   else if (c == '/')
-    successful = readCppStyleComment();
+    successful = this->readCppStyleComment();
   if (!successful)
     return false;
 
-  if (collectComments_) {
+  if (this->collectComments_) {
     CommentPlacement placement = commentBefore;
-    if (lastValueEnd_ && !containsNewLine(lastValueEnd_, commentBegin)) {
-      if (c != '*' || !containsNewLine(commentBegin, current_))
+    if (this->lastValueEnd_ &&
+        !containsNewLine(this->lastValueEnd_, commentBegin)) {
+      if (c != '*' || !containsNewLine(commentBegin, this->current_))
         placement = commentAfterOnSameLine;
     }
 
-    addComment(commentBegin, current_, placement);
+    this->addComment(commentBegin, this->current_, placement);
   }
   return true;
 }
 
-JSONCPP_STRING OurReader::normalizeEOL(OurReader::Location begin, OurReader::Location end) {
+JSONCPP_STRING OurReader::normalizeEOL(OurReader::Location begin,
+                                       OurReader::Location end)
+{
   JSONCPP_STRING normalized;
   normalized.reserve(static_cast<size_t>(end - begin));
   OurReader::Location current = begin;
@@ -1362,8 +1441,8 @@ JSONCPP_STRING OurReader::normalizeEOL(OurReader::Location begin, OurReader::Loc
     char c = *current++;
     if (c == '\r') {
       if (current != end && *current == '\n')
-         // convert dos EOL
-         ++current;
+        // convert dos EOL
+        ++current;
       // convert Mac EOL
       normalized += '\n';
     } else {
@@ -1373,36 +1452,39 @@ JSONCPP_STRING OurReader::normalizeEOL(OurReader::Location begin, OurReader::Loc
   return normalized;
 }
 
-void
-OurReader::addComment(Location begin, Location end, CommentPlacement placement) {
-  assert(collectComments_);
+void OurReader::addComment(Location begin, Location end,
+                           CommentPlacement placement)
+{
+  assert(this->collectComments_);
   const JSONCPP_STRING& normalized = normalizeEOL(begin, end);
   if (placement == commentAfterOnSameLine) {
-    assert(lastValue_ != 0);
-    lastValue_->setComment(normalized, placement);
+    assert(this->lastValue_ != 0);
+    this->lastValue_->setComment(normalized, placement);
   } else {
-    commentsBefore_ += normalized;
+    this->commentsBefore_ += normalized;
   }
 }
 
-bool OurReader::readCStyleComment() {
-  while ((current_ + 1) < end_) {
-    Char c = getNextChar();
-    if (c == '*' && *current_ == '/')
+bool OurReader::readCStyleComment()
+{
+  while ((this->current_ + 1) < this->end_) {
+    Char c = this->getNextChar();
+    if (c == '*' && *this->current_ == '/')
       break;
   }
-  return getNextChar() == '/';
+  return this->getNextChar() == '/';
 }
 
-bool OurReader::readCppStyleComment() {
-  while (current_ != end_) {
-    Char c = getNextChar();
+bool OurReader::readCppStyleComment()
+{
+  while (this->current_ != this->end_) {
+    Char c = this->getNextChar();
     if (c == '\n')
       break;
     if (c == '\r') {
       // Consume DOS EOL. It will be normalized in addComment.
-      if (current_ != end_ && *current_ == '\n')
-        getNextChar();
+      if (this->current_ != this->end_ && *this->current_ == '\n')
+        this->getNextChar();
       // Break on Moc OS 9 EOL.
       break;
     }
@@ -1410,150 +1492,156 @@ bool OurReader::readCppStyleComment() {
   return true;
 }
 
-bool OurReader::readNumber(bool checkInf) {
-  const char *p = current_;
-  if (checkInf && p != end_ && *p == 'I') {
-    current_ = ++p;
+bool OurReader::readNumber(bool checkInf)
+{
+  const char* p = this->current_;
+  if (checkInf && p != this->end_ && *p == 'I') {
+    this->current_ = ++p;
     return false;
   }
   char c = '0'; // stopgap for already consumed character
   // integral part
   while (c >= '0' && c <= '9')
-    c = (current_ = p) < end_ ? *p++ : '\0';
+    c = (this->current_ = p) < this->end_ ? *p++ : '\0';
   // fractional part
   if (c == '.') {
-    c = (current_ = p) < end_ ? *p++ : '\0';
+    c = (this->current_ = p) < this->end_ ? *p++ : '\0';
     while (c >= '0' && c <= '9')
-      c = (current_ = p) < end_ ? *p++ : '\0';
+      c = (this->current_ = p) < this->end_ ? *p++ : '\0';
   }
   // exponential part
   if (c == 'e' || c == 'E') {
-    c = (current_ = p) < end_ ? *p++ : '\0';
+    c = (this->current_ = p) < this->end_ ? *p++ : '\0';
     if (c == '+' || c == '-')
-      c = (current_ = p) < end_ ? *p++ : '\0';
+      c = (this->current_ = p) < this->end_ ? *p++ : '\0';
     while (c >= '0' && c <= '9')
-      c = (current_ = p) < end_ ? *p++ : '\0';
+      c = (this->current_ = p) < this->end_ ? *p++ : '\0';
   }
   return true;
 }
-bool OurReader::readString() {
+bool OurReader::readString()
+{
   Char c = 0;
-  while (current_ != end_) {
-    c = getNextChar();
+  while (this->current_ != this->end_) {
+    c = this->getNextChar();
     if (c == '\\')
-      getNextChar();
+      this->getNextChar();
     else if (c == '"')
       break;
   }
   return c == '"';
 }
 
-
-bool OurReader::readStringSingleQuote() {
+bool OurReader::readStringSingleQuote()
+{
   Char c = 0;
-  while (current_ != end_) {
-    c = getNextChar();
+  while (this->current_ != this->end_) {
+    c = this->getNextChar();
     if (c == '\\')
-      getNextChar();
+      this->getNextChar();
     else if (c == '\'')
       break;
   }
   return c == '\'';
 }
 
-bool OurReader::readObject(Token& tokenStart) {
+bool OurReader::readObject(Token& tokenStart)
+{
   Token tokenName;
   JSONCPP_STRING name;
   Value init(objectValue);
-  currentValue().swapPayload(init);
-  currentValue().setOffsetStart(tokenStart.start_ - begin_);
-  while (readToken(tokenName)) {
+  this->currentValue().swapPayload(init);
+  this->currentValue().setOffsetStart(tokenStart.start_ - this->begin_);
+  while (this->readToken(tokenName)) {
     bool initialTokenOk = true;
     while (tokenName.type_ == tokenComment && initialTokenOk)
-      initialTokenOk = readToken(tokenName);
+      initialTokenOk = this->readToken(tokenName);
     if (!initialTokenOk)
       break;
     if (tokenName.type_ == tokenObjectEnd && name.empty()) // empty object
       return true;
     name.clear();
     if (tokenName.type_ == tokenString) {
-      if (!decodeString(tokenName, name))
-        return recoverFromError(tokenObjectEnd);
-    } else if (tokenName.type_ == tokenNumber && features_.allowNumericKeys_) {
+      if (!this->decodeString(tokenName, name))
+        return this->recoverFromError(tokenObjectEnd);
+    } else if (tokenName.type_ == tokenNumber &&
+               this->features_.allowNumericKeys_) {
       Value numberName;
-      if (!decodeNumber(tokenName, numberName))
-        return recoverFromError(tokenObjectEnd);
+      if (!this->decodeNumber(tokenName, numberName))
+        return this->recoverFromError(tokenObjectEnd);
       name = numberName.asString();
     } else {
       break;
     }
 
     Token colon;
-    if (!readToken(colon) || colon.type_ != tokenMemberSeparator) {
-      return addErrorAndRecover(
-          "Missing ':' after object member name", colon, tokenObjectEnd);
+    if (!this->readToken(colon) || colon.type_ != tokenMemberSeparator) {
+      return this->addErrorAndRecover("Missing ':' after object member name",
+                                      colon, tokenObjectEnd);
     }
-    if (name.length() >= (1U<<30)) throwRuntimeError("keylength >= 2^30");
-    if (features_.rejectDupKeys_ && currentValue().isMember(name)) {
+    if (name.length() >= (1U << 30))
+      throwRuntimeError("keylength >= 2^30");
+    if (this->features_.rejectDupKeys_ &&
+        this->currentValue().isMember(name)) {
       JSONCPP_STRING msg = "Duplicate key: '" + name + "'";
-      return addErrorAndRecover(
-          msg, tokenName, tokenObjectEnd);
+      return this->addErrorAndRecover(msg, tokenName, tokenObjectEnd);
     }
-    Value& value = currentValue()[name];
-    nodes_.push(&value);
-    bool ok = readValue();
-    nodes_.pop();
+    Value& value = this->currentValue()[name];
+    this->nodes_.push(&value);
+    bool ok = this->readValue();
+    this->nodes_.pop();
     if (!ok) // error already set
-      return recoverFromError(tokenObjectEnd);
+      return this->recoverFromError(tokenObjectEnd);
 
     Token comma;
-    if (!readToken(comma) ||
+    if (!this->readToken(comma) ||
         (comma.type_ != tokenObjectEnd && comma.type_ != tokenArraySeparator &&
          comma.type_ != tokenComment)) {
-      return addErrorAndRecover(
-          "Missing ',' or '}' in object declaration", comma, tokenObjectEnd);
+      return this->addErrorAndRecover(
+        "Missing ',' or '}' in object declaration", comma, tokenObjectEnd);
     }
     bool finalizeTokenOk = true;
     while (comma.type_ == tokenComment && finalizeTokenOk)
-      finalizeTokenOk = readToken(comma);
+      finalizeTokenOk = this->readToken(comma);
     if (comma.type_ == tokenObjectEnd)
       return true;
   }
-  return addErrorAndRecover(
-      "Missing '}' or object member name", tokenName, tokenObjectEnd);
+  return this->addErrorAndRecover("Missing '}' or object member name",
+                                  tokenName, tokenObjectEnd);
 }
 
-bool OurReader::readArray(Token& tokenStart) {
+bool OurReader::readArray(Token& tokenStart)
+{
   Value init(arrayValue);
-  currentValue().swapPayload(init);
-  currentValue().setOffsetStart(tokenStart.start_ - begin_);
-  skipSpaces();
-  if (current_ != end_ && *current_ == ']') // empty array
+  this->currentValue().swapPayload(init);
+  this->currentValue().setOffsetStart(tokenStart.start_ - this->begin_);
+  this->skipSpaces();
+  if (this->current_ != this->end_ && *this->current_ == ']') // empty array
   {
     Token endArray;
-    readToken(endArray);
+    this->readToken(endArray);
     return true;
   }
   int index = 0;
   for (;;) {
-    Value& value = currentValue()[index++];
-    nodes_.push(&value);
-    bool ok = readValue();
-    nodes_.pop();
+    Value& value = this->currentValue()[index++];
+    this->nodes_.push(&value);
+    bool ok = this->readValue();
+    this->nodes_.pop();
     if (!ok) // error already set
-      return recoverFromError(tokenArrayEnd);
+      return this->recoverFromError(tokenArrayEnd);
 
     Token token;
     // Accept Comment after last item in the array.
-    ok = readToken(token);
+    ok = this->readToken(token);
     while (token.type_ == tokenComment && ok) {
-      ok = readToken(token);
+      ok = this->readToken(token);
     }
     bool badTokenType =
-        (token.type_ != tokenArraySeparator && token.type_ != tokenArrayEnd);
+      (token.type_ != tokenArraySeparator && token.type_ != tokenArrayEnd);
     if (!ok || badTokenType) {
-      return addErrorAndRecover(
-          "Missing ',' or ']' in array declaration", token, tokenArrayEnd);
+      return this->addErrorAndRecover(
+        "Missing ',' or ']' in array declaration", token, tokenArrayEnd);
     }
     if (token.type_ == tokenArrayEnd)
       break;
@@ -1561,17 +1649,19 @@ bool OurReader::readArray(Token& tokenStart) {
   return true;
 }
 
-bool OurReader::decodeNumber(Token& token) {
+bool OurReader::decodeNumber(Token& token)
+{
   Value decoded;
-  if (!decodeNumber(token, decoded))
+  if (!this->decodeNumber(token, decoded))
     return false;
-  currentValue().swapPayload(decoded);
-  currentValue().setOffsetStart(token.start_ - begin_);
-  currentValue().setOffsetLimit(token.end_ - begin_);
+  this->currentValue().swapPayload(decoded);
+  this->currentValue().setOffsetStart(token.start_ - this->begin_);
+  this->currentValue().setOffsetLimit(token.end_ - this->begin_);
   return true;
 }
 
-bool OurReader::decodeNumber(Token& token, Value& decoded) {
+bool OurReader::decodeNumber(Token& token, Value& decoded)
+{
   // Attempts to parse the number as an integer. If the number is
   // larger than the maximum supported value of an integer then
   // we decode the number as a double.
@@ -1579,16 +1669,17 @@ bool OurReader::decodeNumber(Token& token, Value& decoded) {
   bool isNegative = *current == '-';
   if (isNegative)
     ++current;
-  // TODO: Help the compiler do the div and mod at compile time or get rid of them.
-  Value::LargestUInt maxIntegerValue =
-      isNegative ? Value::LargestUInt(Value::minLargestInt)
-                 : Value::maxLargestUInt;
+  // TODO: Help the compiler do the div and mod at compile time or get rid of
+  // them.
+  Value::LargestUInt maxIntegerValue = isNegative
+    ? Value::LargestUInt(Value::minLargestInt)
+    : Value::maxLargestUInt;
   Value::LargestUInt threshold = maxIntegerValue / 10;
   Value::LargestUInt value = 0;
   while (current < token.end_) {
     Char c = *current++;
     if (c < '0' || c > '9')
-      return decodeDouble(token, decoded);
+      return this->decodeDouble(token, decoded);
     Value::UInt digit(static_cast<Value::UInt>(c - '0'));
     if (value >= threshold) {
       // We've hit or exceeded the max value divided by 10 (rounded down). If
@@ -1597,7 +1688,7 @@ bool OurReader::decodeNumber(Token& token, Value& decoded) {
       // Otherwise treat this number as a double to avoid overflow.
       if (value > threshold || current != token.end_ ||
           digit > maxIntegerValue % 10) {
-        return decodeDouble(token, decoded);
+        return this->decodeDouble(token, decoded);
       }
     }
     value = value * 10 + digit;
@@ -1611,17 +1702,19 @@ bool OurReader::decodeNumber(Token& token, Value& decoded) {
   return true;
 }
 
-bool OurReader::decodeDouble(Token& token) {
+bool OurReader::decodeDouble(Token& token)
+{
   Value decoded;
-  if (!decodeDouble(token, decoded))
+  if (!this->decodeDouble(token, decoded))
     return false;
-  currentValue().swapPayload(decoded);
-  currentValue().setOffsetStart(token.start_ - begin_);
-  currentValue().setOffsetLimit(token.end_ - begin_);
+  this->currentValue().swapPayload(decoded);
+  this->currentValue().setOffsetStart(token.start_ - this->begin_);
+  this->currentValue().setOffsetLimit(token.end_ - this->begin_);
   return true;
 }
 
-bool OurReader::decodeDouble(Token& token, Value& decoded) {
+bool OurReader::decodeDouble(Token& token, Value& decoded)
+{
   double value = 0;
   const int bufferSize = 32;
   int count;
@@ -1629,7 +1722,7 @@ bool OurReader::decodeDouble(Token& token, Value& decoded) {
 
   // Sanity check to avoid buffer overflow exploits.
   if (length < 0) {
-    return addError("Unable to parse token length", token);
+    return this->addError("Unable to parse token length", token);
   }
   size_t const ulength = static_cast<size_t>(length);
 
@@ -1652,25 +1745,27 @@ bool OurReader::decodeDouble(Token& token, Value& decoded) {
   }
 
   if (count != 1)
-    return addError("'" + JSONCPP_STRING(token.start_, token.end_) +
-                        "' is not a number.",
-                    token);
+    return this->addError("'" + JSONCPP_STRING(token.start_, token.end_) +
+                            "' is not a number.",
+                          token);
   decoded = value;
   return true;
 }
 
-bool OurReader::decodeString(Token& token) {
+bool OurReader::decodeString(Token& token)
+{
   JSONCPP_STRING decoded_string;
-  if (!decodeString(token, decoded_string))
+  if (!this->decodeString(token, decoded_string))
     return false;
   Value decoded(decoded_string);
-  currentValue().swapPayload(decoded);
-  currentValue().setOffsetStart(token.start_ - begin_);
-  currentValue().setOffsetLimit(token.end_ - begin_);
+  this->currentValue().swapPayload(decoded);
+  this->currentValue().setOffsetStart(token.start_ - this->begin_);
+  this->currentValue().setOffsetLimit(token.end_ - this->begin_);
   return true;
 }
 
-bool OurReader::decodeString(Token& token, JSONCPP_STRING& decoded) {
+bool OurReader::decodeString(Token& token, JSONCPP_STRING& decoded)
+{
   decoded.reserve(static_cast<size_t>(token.end_ - token.start_ - 2));
   Location current = token.start_ + 1; // skip '"'
   Location end = token.end_ - 1;       // do not include '"'
@@ -1680,41 +1775,43 @@ bool OurReader::decodeString(Token& token, JSONCPP_STRING& decoded) {
       break;
     else if (c == '\\') {
       if (current == end)
-        return addError("Empty escape sequence in string", token, current);
+        return this->addError("Empty escape sequence in string", token,
+                              current);
       Char escape = *current++;
       switch (escape) {
-      case '"':
-        decoded += '"';
-        break;
-      case '/':
-        decoded += '/';
-        break;
-      case '\\':
-        decoded += '\\';
-        break;
-      case 'b':
-        decoded += '\b';
-        break;
-      case 'f':
-        decoded += '\f';
-        break;
-      case 'n':
-        decoded += '\n';
-        break;
-      case 'r':
-        decoded += '\r';
-        break;
-      case 't':
-        decoded += '\t';
-        break;
-      case 'u': {
-        unsigned int unicode;
-        if (!decodeUnicodeCodePoint(token, current, end, unicode))
-          return false;
-        decoded += codePointToUTF8(unicode);
-      } break;
-      default:
-        return addError("Bad escape sequence in string", token, current);
+        case '"':
+          decoded += '"';
+          break;
+        case '/':
+          decoded += '/';
+          break;
+        case '\\':
+          decoded += '\\';
+          break;
+        case 'b':
+          decoded += '\b';
+          break;
+        case 'f':
+          decoded += '\f';
+          break;
+        case 'n':
+          decoded += '\n';
+          break;
+        case 'r':
+          decoded += '\r';
+          break;
+        case 't':
+          decoded += '\t';
+          break;
+        case 'u': {
+          unsigned int unicode;
+          if (!this->decodeUnicodeCodePoint(token, current, end, unicode))
+            return false;
+          decoded += codePointToUTF8(unicode);
+        } break;
+        default:
+          return this->addError("Bad escape sequence in string", token,
+                                current);
       }
     } else {
       decoded += c;
@@ -1723,45 +1820,44 @@ bool OurReader::decodeString(Token& token, JSONCPP_STRING& decoded) {
   return true;
 }
 
-bool OurReader::decodeUnicodeCodePoint(Token& token,
-                                    Location& current,
-                                    Location end,
-                                    unsigned int& unicode) {
+bool OurReader::decodeUnicodeCodePoint(Token& token, Location& current,
+                                       Location end, unsigned int& unicode)
+{
 
   unicode = 0; // Convince scanbuild this is always initialized before use.
-  if (!decodeUnicodeEscapeSequence(token, current, end, unicode))
+  if (!this->decodeUnicodeEscapeSequence(token, current, end, unicode))
     return false;
   if (unicode >= 0xD800 && unicode <= 0xDBFF) {
     // surrogate pairs
     if (end - current < 6)
-      return addError(
-          "additional six characters expected to parse unicode surrogate pair.",
-          token,
-          current);
+      return this->addError(
+        "additional six characters expected to parse unicode surrogate pair.",
+        token, current);
     unsigned int surrogatePair;
     if (*(current++) == '\\' && *(current++) == 'u') {
-      if (decodeUnicodeEscapeSequence(token, current, end, surrogatePair)) {
-        unicode = 0x10000 + ((unicode & 0x3FF) << 10) + (surrogatePair & 0x3FF);
+      if (this->decodeUnicodeEscapeSequence(token, current, end,
+                                            surrogatePair)) {
+        unicode =
+          0x10000 + ((unicode & 0x3FF) << 10) + (surrogatePair & 0x3FF);
       } else
         return false;
     } else
-      return addError("expecting another \\u token to begin the second half of "
-                      "a unicode surrogate pair",
-                      token,
-                      current);
+      return this->addError(
+        "expecting another \\u token to begin the second half of "
+        "a unicode surrogate pair",
+        token, current);
   }
   return true;
 }
 
-bool OurReader::decodeUnicodeEscapeSequence(Token& token,
-                                         Location& current,
-                                         Location end,
-                                         unsigned int& ret_unicode) {
+bool OurReader::decodeUnicodeEscapeSequence(Token& token, Location& current,
+                                            Location end,
+                                            unsigned int& ret_unicode)
+{
   if (end - current < 4)
-    return addError(
-        "Bad unicode escape sequence in string: four digits expected.",
-        token,
-        current);
+    return this->addError(
+      "Bad unicode escape sequence in string: four digits expected.", token,
+      current);
   int unicode = 0;
   for (int index = 0; index < 4; ++index) {
     Char c = *current++;
@@ -1773,60 +1869,65 @@ bool OurReader::decodeUnicodeEscapeSequence(Token& token,
     else if (c >= 'A' && c <= 'F')
       unicode += c - 'A' + 10;
     else
-      return addError(
-          "Bad unicode escape sequence in string: hexadecimal digit expected.",
-          token,
-          current);
+      return this->addError(
+        "Bad unicode escape sequence in string: hexadecimal digit expected.",
+        token, current);
   }
   ret_unicode = static_cast<unsigned int>(unicode);
   return true;
 }
 
-bool
-OurReader::addError(const JSONCPP_STRING& message, Token& token, Location extra) {
+bool OurReader::addError(const JSONCPP_STRING& message, Token& token,
+                         Location extra)
+{
   ErrorInfo info;
   info.token_ = token;
   info.message_ = message;
   info.extra_ = extra;
-  errors_.push_back(info);
+  this->errors_.push_back(info);
   return false;
 }
 
-bool OurReader::recoverFromError(TokenType skipUntilToken) {
-  size_t errorCount = errors_.size();
+bool OurReader::recoverFromError(TokenType skipUntilToken)
+{
+  size_t errorCount = this->errors_.size();
   Token skip;
   for (;;) {
-    if (!readToken(skip))
-      errors_.resize(errorCount); // discard errors caused by recovery
+    if (!this->readToken(skip))
+      this->errors_.resize(errorCount); // discard errors caused by recovery
     if (skip.type_ == skipUntilToken || skip.type_ == tokenEndOfStream)
       break;
   }
-  errors_.resize(errorCount);
+  this->errors_.resize(errorCount);
   return false;
 }
 
-bool OurReader::addErrorAndRecover(const JSONCPP_STRING& message,
-                                Token& token,
-                                TokenType skipUntilToken) {
-  addError(message, token);
-  return recoverFromError(skipUntilToken);
+bool OurReader::addErrorAndRecover(const JSONCPP_STRING& message, Token& token,
+                                   TokenType skipUntilToken)
+{
+  this->addError(message, token);
+  return this->recoverFromError(skipUntilToken);
 }
 
-Value& OurReader::currentValue() { return *(nodes_.top()); }
+Value& OurReader::currentValue()
+{
+  return *(this->nodes_.top());
+}
 
-OurReader::Char OurReader::getNextChar() {
-  if (current_ == end_)
+OurReader::Char OurReader::getNextChar()
+{
+  if (this->current_ == this->end_)
     return 0;
-  return *current_++;
+  return *this->current_++;
 }
 
-void OurReader::getLocationLineAndColumn(Location location,
-                                      int& line,
-                                      int& column) const {
-  Location current = begin_;
+void OurReader::getLocationLineAndColumn(Location location, int& line,
+                                         int& column) const
+{
+  Location current = this->begin_;
   Location lastLineStart = current;
   line = 0;
-  while (current < location && current != end_) {
+  while (current < location && current != this->end_) {
     Char c = *current++;
     if (c == '\r') {
       if (*current == '\n')
@@ -1843,101 +1944,105 @@ void OurReader::getLocationLineAndColumn(Location location,
   ++line;
 }
 
-JSONCPP_STRING OurReader::getLocationLineAndColumn(Location location) const {
+JSONCPP_STRING OurReader::getLocationLineAndColumn(Location location) const
+{
   int line, column;
-  getLocationLineAndColumn(location, line, column);
+  this->getLocationLineAndColumn(location, line, column);
   char buffer[18 + 16 + 16 + 1];
   snprintf(buffer, sizeof(buffer), "Line %d, Column %d", line, column);
   return buffer;
 }
 
-JSONCPP_STRING OurReader::getFormattedErrorMessages() const {
+JSONCPP_STRING OurReader::getFormattedErrorMessages() const
+{
   JSONCPP_STRING formattedMessage;
-  for (Errors::const_iterator itError = errors_.begin();
-       itError != errors_.end();
-       ++itError) {
+  for (Errors::const_iterator itError = this->errors_.begin();
+       itError != this->errors_.end(); ++itError) {
     const ErrorInfo& error = *itError;
     formattedMessage +=
-        "* " + getLocationLineAndColumn(error.token_.start_) + "\n";
+      "* " + this->getLocationLineAndColumn(error.token_.start_) + "\n";
     formattedMessage += "  " + error.message_ + "\n";
     if (error.extra_)
-      formattedMessage +=
-          "See " + getLocationLineAndColumn(error.extra_) + " for detail.\n";
+      formattedMessage += "See " +
+        this->getLocationLineAndColumn(error.extra_) + " for detail.\n";
   }
   return formattedMessage;
 }
 
-std::vector<OurReader::StructuredError> OurReader::getStructuredErrors() const {
+std::vector<OurReader::StructuredError> OurReader::getStructuredErrors() const
+{
   std::vector<OurReader::StructuredError> allErrors;
-  for (Errors::const_iterator itError = errors_.begin();
-       itError != errors_.end();
-       ++itError) {
+  for (Errors::const_iterator itError = this->errors_.begin();
+       itError != this->errors_.end(); ++itError) {
     const ErrorInfo& error = *itError;
     OurReader::StructuredError structured;
-    structured.offset_start = error.token_.start_ - begin_;
-    structured.offset_limit = error.token_.end_ - begin_;
+    structured.offset_start = error.token_.start_ - this->begin_;
+    structured.offset_limit = error.token_.end_ - this->begin_;
     structured.message = error.message_;
     allErrors.push_back(structured);
   }
   return allErrors;
 }
 
-bool OurReader::pushError(const Value& value, const JSONCPP_STRING& message) {
-  ptrdiff_t length = end_ - begin_;
-  if(value.getOffsetStart() > length
-    || value.getOffsetLimit() > length)
+bool OurReader::pushError(const Value& value, const JSONCPP_STRING& message)
+{
+  ptrdiff_t length = this->end_ - this->begin_;
+  if (value.getOffsetStart() > length || value.getOffsetLimit() > length)
     return false;
   Token token;
   token.type_ = tokenError;
-  token.start_ = begin_ + value.getOffsetStart();
-  token.end_ = end_ + value.getOffsetLimit();
+  token.start_ = this->begin_ + value.getOffsetStart();
+  token.end_ = this->end_ + value.getOffsetLimit();
   ErrorInfo info;
   info.token_ = token;
   info.message_ = message;
   info.extra_ = 0;
-  errors_.push_back(info);
+  this->errors_.push_back(info);
   return true;
 }
 
-bool OurReader::pushError(const Value& value, const JSONCPP_STRING& message, const Value& extra) {
-  ptrdiff_t length = end_ - begin_;
-  if(value.getOffsetStart() > length
-    || value.getOffsetLimit() > length
-    || extra.getOffsetLimit() > length)
+bool OurReader::pushError(const Value& value, const JSONCPP_STRING& message,
+                          const Value& extra)
+{
+  ptrdiff_t length = this->end_ - this->begin_;
+  if (value.getOffsetStart() > length || value.getOffsetLimit() > length ||
+      extra.getOffsetLimit() > length)
     return false;
   Token token;
   token.type_ = tokenError;
-  token.start_ = begin_ + value.getOffsetStart();
-  token.end_ = begin_ + value.getOffsetLimit();
+  token.start_ = this->begin_ + value.getOffsetStart();
+  token.end_ = this->begin_ + value.getOffsetLimit();
   ErrorInfo info;
   info.token_ = token;
   info.message_ = message;
-  info.extra_ = begin_ + extra.getOffsetStart();
-  errors_.push_back(info);
+  info.extra_ = this->begin_ + extra.getOffsetStart();
+  this->errors_.push_back(info);
   return true;
 }
 
-bool OurReader::good() const {
-  return !errors_.size();
+bool OurReader::good() const
+{
+  return !this->errors_.size();
 }
 
-
-class OurCharReader : public CharReader {
+class OurCharReader : public CharReader
+{
   bool const collectComments_;
   OurReader reader_;
+
 public:
-  OurCharReader(
-    bool collectComments,
-    OurFeatures const& features)
-  : collectComments_(collectComments)
-  , reader_(features)
-  {}
-  bool parse(
-      char const* beginDoc, char const* endDoc,
-      Value* root, JSONCPP_STRING* errs) JSONCPP_OVERRIDE {
-    bool ok = reader_.parse(beginDoc, endDoc, *root, collectComments_);
+  OurCharReader(bool collectComments, OurFeatures const& features)
+    : collectComments_(collectComments)
+    , reader_(features)
+  {
+  }
+  bool parse(char const* beginDoc, char const* endDoc, Value* root,
+             JSONCPP_STRING* errs) JSONCPP_OVERRIDE
+  {
+    bool ok =
+      this->reader_.parse(beginDoc, endDoc, *root, this->collectComments_);
     if (errs) {
-      *errs = reader_.getFormattedErrorMessages();
+      *errs = this->reader_.getFormattedErrorMessages();
     }
     return ok;
   }
@@ -1945,23 +2050,26 @@ public:
 
 CharReaderBuilder::CharReaderBuilder()
 {
-  setDefaults(&settings_);
+  setDefaults(&this->settings_);
 }
 CharReaderBuilder::~CharReaderBuilder()
-{}
+{
+}
 CharReader* CharReaderBuilder::newCharReader() const
 {
-  bool collectComments = settings_["collectComments"].asBool();
+  bool collectComments = this->settings_["collectComments"].asBool();
   OurFeatures features = OurFeatures::all();
-  features.allowComments_ = settings_["allowComments"].asBool();
-  features.strictRoot_ = settings_["strictRoot"].asBool();
-  features.allowDroppedNullPlaceholders_ = settings_["allowDroppedNullPlaceholders"].asBool();
-  features.allowNumericKeys_ = settings_["allowNumericKeys"].asBool();
-  features.allowSingleQuotes_ = settings_["allowSingleQuotes"].asBool();
-  features.stackLimit_ = settings_["stackLimit"].asInt();
-  features.failIfExtra_ = settings_["failIfExtra"].asBool();
-  features.rejectDupKeys_ = settings_["rejectDupKeys"].asBool();
-  features.allowSpecialFloats_ = settings_["allowSpecialFloats"].asBool();
+  features.allowComments_ = this->settings_["allowComments"].asBool();
+  features.strictRoot_ = this->settings_["strictRoot"].asBool();
+  features.allowDroppedNullPlaceholders_ =
+    this->settings_["allowDroppedNullPlaceholders"].asBool();
+  features.allowNumericKeys_ = this->settings_["allowNumericKeys"].asBool();
+  features.allowSingleQuotes_ = this->settings_["allowSingleQuotes"].asBool();
+  features.stackLimit_ = this->settings_["stackLimit"].asInt();
+  features.failIfExtra_ = this->settings_["failIfExtra"].asBool();
+  features.rejectDupKeys_ = this->settings_["rejectDupKeys"].asBool();
+  features.allowSpecialFloats_ =
+    this->settings_["allowSpecialFloats"].asBool();
   return new OurCharReader(collectComments, features);
 }
 static void getValidReaderKeys(std::set<JSONCPP_STRING>* valid_keys)
@@ -1981,28 +2089,29 @@ static void getValidReaderKeys(std::set<JSONCPP_STRING>* valid_keys)
 bool CharReaderBuilder::validate(Json::Value* invalid) const
 {
   Json::Value my_invalid;
-  if (!invalid) invalid = &my_invalid;  // so we do not need to test for NULL
+  if (!invalid)
+    invalid = &my_invalid; // so we do not need to test for NULL
   Json::Value& inv = *invalid;
   std::set<JSONCPP_STRING> valid_keys;
   getValidReaderKeys(&valid_keys);
-  Value::Members keys = settings_.getMemberNames();
+  Value::Members keys = this->settings_.getMemberNames();
   size_t n = keys.size();
   for (size_t i = 0; i < n; ++i) {
     JSONCPP_STRING const& key = keys[i];
     if (valid_keys.find(key) == valid_keys.end()) {
-      inv[key] = settings_[key];
+      inv[key] = this->settings_[key];
     }
   }
   return 0u == inv.size();
 }
 Value& CharReaderBuilder::operator[](JSONCPP_STRING key)
 {
-  return settings_[key];
+  return this->settings_[key];
 }
 // static
 void CharReaderBuilder::strictMode(Json::Value* settings)
 {
-//! [CharReaderBuilderStrictMode]
+  //! [CharReaderBuilderStrictMode]
   (*settings)["allowComments"] = false;
   (*settings)["strictRoot"] = true;
   (*settings)["allowDroppedNullPlaceholders"] = false;
@@ -2012,12 +2121,12 @@ void CharReaderBuilder::strictMode(Json::Value* settings)
   (*settings)["failIfExtra"] = true;
   (*settings)["rejectDupKeys"] = true;
   (*settings)["allowSpecialFloats"] = false;
-//! [CharReaderBuilderStrictMode]
+  //! [CharReaderBuilderStrictMode]
 }
 // static
 void CharReaderBuilder::setDefaults(Json::Value* settings)
 {
-//! [CharReaderBuilderDefaults]
+  //! [CharReaderBuilderDefaults]
   (*settings)["collectComments"] = true;
   (*settings)["allowComments"] = true;
   (*settings)["strictRoot"] = false;
@@ -2028,15 +2137,14 @@ void CharReaderBuilder::setDefaults(Json::Value* settings)
   (*settings)["failIfExtra"] = false;
   (*settings)["rejectDupKeys"] = false;
   (*settings)["allowSpecialFloats"] = false;
-//! [CharReaderBuilderDefaults]
+  //! [CharReaderBuilderDefaults]
 }
 
 //////////////////////////////////
 // global functions
 
-bool parseFromStream(
-    CharReader::Factory const& fact, JSONCPP_ISTREAM& sin,
-    Value* root, JSONCPP_STRING* errs)
+bool parseFromStream(CharReader::Factory const& fact, JSONCPP_ISTREAM& sin,
+                     Value* root, JSONCPP_STRING* errs)
 {
   JSONCPP_OSTRINGSTREAM ssin;
   ssin << sin.rdbuf();
@@ -2048,14 +2156,13 @@ bool parseFromStream(
   return reader->parse(begin, end, root, errs);
 }
 
-JSONCPP_ISTREAM& operator>>(JSONCPP_ISTREAM& sin, Value& root) {
+JSONCPP_ISTREAM& operator>>(JSONCPP_ISTREAM& sin, Value& root)
+{
   CharReaderBuilder b;
   JSONCPP_STRING errs;
   bool ok = parseFromStream(b, sin, &root, &errs);
   if (!ok) {
-    fprintf(stderr,
-            "Error from reader: %s",
-            errs.c_str());
+    fprintf(stderr, "Error from reader: %s", errs.c_str());
 
     throwRuntimeError(errs);
   }
diff --git a/Utilities/cmjsoncpp/src/lib_json/json_value.cpp b/Utilities/cmjsoncpp/src/lib_json/json_value.cpp
index f271e5731f..eadb1c375e 100644
--- a/Utilities/cmjsoncpp/src/lib_json/json_value.cpp
+++ b/Utilities/cmjsoncpp/src/lib_json/json_value.cpp
@@ -1,23 +1,25 @@
 // Copyright 2011 Baptiste Lepilleur and The JsonCpp Authors
 // Distributed under MIT license, or public domain if desired and
 // recognized in your jurisdiction.
-// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+// See file LICENSE for detail or copy at
+// http://jsoncpp.sourceforge.net/LICENSE
 
 #if !defined(JSON_IS_AMALGAMATION)
-#include <json/assertions.h>
-#include <json/value.h>
-#include <json/writer.h>
+#  include <json/assertions.h>
+#  include <json/value.h>
+#  include <json/writer.h>
 #endif // if !defined(JSON_IS_AMALGAMATION)
-#include <math.h>
 #include <sstream>
 #include <utility>
-#include <string.h>
+
 #include <assert.h>
+#include <math.h>
+#include <string.h>
 #ifdef JSON_USE_CPPTL
-#include <cpptl/conststring.h>
+#  include <cpptl/conststring.h>
 #endif
-#include <cstddef> // size_t
 #include <algorithm> // min()
+#include <cstddef>   // size_t
 
 #define JSON_ASSERT_UNREACHABLE assert(false)
 
@@ -27,24 +29,24 @@ namespace Json {
 // kNull must be word-aligned to avoid crashing on ARM.  We use an alignment of
 // 8 (instead of 4) as a bit of future-proofing.
 #if defined(__ARMEL__)
-#define ALIGNAS(byte_alignment) __attribute__((aligned(byte_alignment)))
+#  define ALIGNAS(byte_alignment) __attribute__((aligned(byte_alignment)))
 #else
-#define ALIGNAS(byte_alignment)
+#  define ALIGNAS(byte_alignment)
 #endif
-//static const unsigned char ALIGNAS(8) kNull[sizeof(Value)] = { 0 };
-//const unsigned char& kNullRef = kNull[0];
-//const Value& Value::null = reinterpret_cast<const Value&>(kNullRef);
-//const Value& Value::nullRef = null;
+// static const unsigned char ALIGNAS(8) kNull[sizeof(Value)] = { 0 };
+// const unsigned char& kNullRef = kNull[0];
+// const Value& Value::null = reinterpret_cast<const Value&>(kNullRef);
+// const Value& Value::nullRef = null;
 
 // static
 Value const& Value::nullSingleton()
 {
- static Value const nullStatic;
- return nullStatic;
+  static Value const nullStatic;
+  return nullStatic;
 }
 
-// for backwards compatibility, we'll leave these global references around, but DO NOT
-// use them in JSONCPP library code any more!
+// for backwards compatibility, we'll leave these global references around, but
+// DO NOT use them in JSONCPP library code any more!
 Value const& Value::null = Value::nullSingleton();
 Value const& Value::nullRef = Value::nullSingleton();
 
@@ -66,23 +68,29 @@ const LargestUInt Value::maxLargestUInt = LargestUInt(-1);
 
 #if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
 template <typename T, typename U>
-static inline bool InRange(double d, T min, U max) {
+static inline bool InRange(double d, T min, U max)
+{
   // The casts can lose precision, but we are looking only for
   // an approximate range. Might fail on edge cases though. ~cdunn
-  //return d >= static_cast<double>(min) && d <= static_cast<double>(max);
+  // return d >= static_cast<double>(min) && d <= static_cast<double>(max);
   return d >= min && d <= max;
 }
 #else  // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
-static inline double integerToDouble(Json::UInt64 value) {
-  return static_cast<double>(Int64(value / 2)) * 2.0 + static_cast<double>(Int64(value & 1));
+static inline double integerToDouble(Json::UInt64 value)
+{
+  return static_cast<double>(Int64(value / 2)) * 2.0 +
+    static_cast<double>(Int64(value & 1));
 }
 
-template <typename T> static inline double integerToDouble(T value) {
+template <typename T>
+static inline double integerToDouble(T value)
+{
   return static_cast<double>(value);
 }
 
 template <typename T, typename U>
-static inline bool InRange(double d, T min, U max) {
+static inline bool InRange(double d, T min, U max)
+{
   return d >= integerToDouble(min) && d <= integerToDouble(max);
 }
 #endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
@@ -94,8 +102,7 @@ static inline bool InRange(double d, T min, U max) {
  *               computed using strlen(value).
  * @return Pointer on the duplicate instance of string.
  */
-static inline char* duplicateStringValue(const char* value,
-                                         size_t length)
+static inline char* duplicateStringValue(const char* value, size_t length)
 {
   // Avoid an integer overflow in the call to malloc below by limiting length
   // to a sane value.
@@ -104,9 +111,8 @@ static inline char* duplicateStringValue(const char* value,
 
   char* newString = static_cast<char*>(malloc(length + 1));
   if (newString == NULL) {
-    throwRuntimeError(
-        "in Json::Value::duplicateStringValue(): "
-        "Failed to allocate string value buffer");
+    throwRuntimeError("in Json::Value::duplicateStringValue(): "
+                      "Failed to allocate string value buffer");
   }
   memcpy(newString, value, length);
   newString[length] = 0;
@@ -115,30 +121,30 @@ static inline char* duplicateStringValue(const char* value,
 
 /* Record the length as a prefix.
  */
-static inline char* duplicateAndPrefixStringValue(
-    const char* value,
-    unsigned int length)
+static inline char* duplicateAndPrefixStringValue(const char* value,
+                                                  unsigned int length)
 {
   // Avoid an integer overflow in the call to malloc below by limiting length
   // to a sane value.
-  JSON_ASSERT_MESSAGE(length <= static_cast<unsigned>(Value::maxInt) - sizeof(unsigned) - 1U,
+  JSON_ASSERT_MESSAGE(length <= static_cast<unsigned>(Value::maxInt) -
+                          sizeof(unsigned) - 1U,
                       "in Json::Value::duplicateAndPrefixStringValue(): "
                       "length too big for prefixing");
-  unsigned actualLength = length + static_cast<unsigned>(sizeof(unsigned)) + 1U;
+  unsigned actualLength =
+    length + static_cast<unsigned>(sizeof(unsigned)) + 1U;
   char* newString = static_cast<char*>(malloc(actualLength));
   if (newString == 0) {
-    throwRuntimeError(
-        "in Json::Value::duplicateAndPrefixStringValue(): "
-        "Failed to allocate string value buffer");
+    throwRuntimeError("in Json::Value::duplicateAndPrefixStringValue(): "
+                      "Failed to allocate string value buffer");
   }
   *reinterpret_cast<unsigned*>(newString) = length;
   memcpy(newString + sizeof(unsigned), value, length);
-  newString[actualLength - 1U] = 0; // to avoid buffer over-run accidents by users later
+  newString[actualLength - 1U] =
+    0; // to avoid buffer over-run accidents by users later
   return newString;
 }
-inline static void decodePrefixedString(
-    bool isPrefixed, char const* prefixed,
-    unsigned* length, char const** value)
+inline static void decodePrefixedString(bool isPrefixed, char const* prefixed,
+                                        unsigned* length, char const** value)
 {
   if (!isPrefixed) {
     *length = static_cast<unsigned>(strlen(prefixed));
@@ -148,10 +154,12 @@ inline static void decodePrefixedString(
     *value = prefixed + sizeof(unsigned);
   }
 }
-/** Free the string duplicated by duplicateStringValue()/duplicateAndPrefixStringValue().
+/** Free the string duplicated by
+ * duplicateStringValue()/duplicateAndPrefixStringValue().
  */
 #if JSONCPP_USING_SECURE_MEMORY
-static inline void releasePrefixedStringValue(char* value) {
+static inline void releasePrefixedStringValue(char* value)
+{
   unsigned length = 0;
   char const* valueDecoded;
   decodePrefixedString(true, value, &length, &valueDecoded);
@@ -159,17 +167,20 @@ static inline void releasePrefixedStringValue(char* value) {
   memset(value, 0, size);
   free(value);
 }
-static inline void releaseStringValue(char* value, unsigned length) {
+static inline void releaseStringValue(char* value, unsigned length)
+{
   // length==0 => we allocated the strings memory
-  size_t size = (length==0) ? strlen(value) : length;
+  size_t size = (length == 0) ? strlen(value) : length;
   memset(value, 0, size);
   free(value);
 }
-#else // !JSONCPP_USING_SECURE_MEMORY
-static inline void releasePrefixedStringValue(char* value) {
+#else  // !JSONCPP_USING_SECURE_MEMORY
+static inline void releasePrefixedStringValue(char* value)
+{
   free(value);
 }
-static inline void releaseStringValue(char* value, unsigned) {
+static inline void releaseStringValue(char* value, unsigned)
+{
   free(value);
 }
 #endif // JSONCPP_USING_SECURE_MEMORY
@@ -185,26 +196,30 @@ static inline void releaseStringValue(char* value, unsigned) {
 // //////////////////////////////////////////////////////////////////
 #if !defined(JSON_IS_AMALGAMATION)
 
-#include "json_valueiterator.inl"
+#  include "json_valueiterator.inl"
 #endif // if !defined(JSON_IS_AMALGAMATION)
 
 namespace Json {
 
 Exception::Exception(JSONCPP_STRING const& msg)
   : msg_(msg)
-{}
+{
+}
 Exception::~Exception() JSONCPP_NOEXCEPT
-{}
+{
+}
 char const* Exception::what() const JSONCPP_NOEXCEPT
 {
-  return msg_.c_str();
+  return this->msg_.c_str();
 }
 RuntimeError::RuntimeError(JSONCPP_STRING const& msg)
   : Exception(msg)
-{}
+{
+}
 LogicError::LogicError(JSONCPP_STRING const& msg)
   : Exception(msg)
-{}
+{
+}
 JSONCPP_NORETURN void throwRuntimeError(JSONCPP_STRING const& msg)
 {
   throw RuntimeError(msg);
@@ -222,25 +237,29 @@ JSONCPP_NORETURN void throwLogicError(JSONCPP_STRING const& msg)
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
 
-Value::CommentInfo::CommentInfo() : comment_(0)
-{}
+Value::CommentInfo::CommentInfo()
+  : comment_(0)
+{
+}
 
-Value::CommentInfo::~CommentInfo() {
-  if (comment_)
-    releaseStringValue(comment_, 0u);
+Value::CommentInfo::~CommentInfo()
+{
+  if (this->comment_)
+    releaseStringValue(this->comment_, 0u);
 }
 
-void Value::CommentInfo::setComment(const char* text, size_t len) {
-  if (comment_) {
-    releaseStringValue(comment_, 0u);
-    comment_ = 0;
+void Value::CommentInfo::setComment(const char* text, size_t len)
+{
+  if (this->comment_) {
+    releaseStringValue(this->comment_, 0u);
+    this->comment_ = 0;
   }
   JSON_ASSERT(text != 0);
   JSON_ASSERT_MESSAGE(
-      text[0] == '\0' || text[0] == '/',
-      "in Json::Value::setComment(): Comments must start with /");
+    text[0] == '\0' || text[0] == '/',
+    "in Json::Value::setComment(): Comments must start with /");
   // It seems that /**/ style comments are acceptable as well.
-  comment_ = duplicateStringValue(text, len);
+  this->comment_ = duplicateStringValue(text, len);
 }
 
 // //////////////////////////////////////////////////////////////////
@@ -254,91 +273,130 @@ void Value::CommentInfo::setComment(const char* text, size_t len) {
 // Notes: policy_ indicates if the string was allocated when
 // a string is stored.
 
-Value::CZString::CZString(ArrayIndex aindex) : cstr_(0), index_(aindex) {}
+Value::CZString::CZString(ArrayIndex aindex)
+  : cstr_(0)
+  , index_(aindex)
+{
+}
 
-Value::CZString::CZString(char const* str, unsigned ulength, DuplicationPolicy allocate)
-    : cstr_(str) {
+Value::CZString::CZString(char const* str, unsigned ulength,
+                          DuplicationPolicy allocate)
+  : cstr_(str)
+{
   // allocate != duplicate
-  storage_.policy_ = allocate & 0x3;
-  storage_.length_ = ulength & 0x3FFFFFFF;
+  this->storage_.policy_ = allocate & 0x3;
+  this->storage_.length_ = ulength & 0x3FFFFFFF;
 }
 
-Value::CZString::CZString(const CZString& other) {
-  cstr_ = (other.storage_.policy_ != noDuplication && other.cstr_ != 0
-				 ? duplicateStringValue(other.cstr_, other.storage_.length_)
-				 : other.cstr_);
-  storage_.policy_ = static_cast<unsigned>(other.cstr_
-                 ? (static_cast<DuplicationPolicy>(other.storage_.policy_) == noDuplication
-                     ? noDuplication : duplicate)
-                 : static_cast<DuplicationPolicy>(other.storage_.policy_)) & 3U;
-  storage_.length_ = other.storage_.length_;
+Value::CZString::CZString(const CZString& other)
+{
+  this->cstr_ = (other.storage_.policy_ != noDuplication && other.cstr_ != 0
+                   ? duplicateStringValue(other.cstr_, other.storage_.length_)
+                   : other.cstr_);
+  this->storage_.policy_ =
+    static_cast<unsigned>(
+      other.cstr_ ? (static_cast<DuplicationPolicy>(other.storage_.policy_) ==
+                         noDuplication
+                       ? noDuplication
+                       : duplicate)
+                  : static_cast<DuplicationPolicy>(other.storage_.policy_)) &
+    3U;
+  this->storage_.length_ = other.storage_.length_;
 }
 
 #if JSON_HAS_RVALUE_REFERENCES
 Value::CZString::CZString(CZString&& other)
-  : cstr_(other.cstr_), index_(other.index_) {
+  : cstr_(other.cstr_)
+  , index_(other.index_)
+{
   other.cstr_ = nullptr;
 }
 #endif
 
-Value::CZString::~CZString() {
-  if (cstr_ && storage_.policy_ == duplicate) {
-	  releaseStringValue(const_cast<char*>(cstr_), storage_.length_ + 1u); //+1 for null terminating character for sake of completeness but not actually necessary
+Value::CZString::~CZString()
+{
+  if (this->cstr_ && this->storage_.policy_ == duplicate) {
+    releaseStringValue(const_cast<char*>(this->cstr_),
+                       this->storage_.length_ +
+                         1u); //+1 for null terminating character for sake of
+                              //completeness but not actually necessary
   }
 }
 
-void Value::CZString::swap(CZString& other) {
-  std::swap(cstr_, other.cstr_);
-  std::swap(index_, other.index_);
+void Value::CZString::swap(CZString& other)
+{
+  std::swap(this->cstr_, other.cstr_);
+  std::swap(this->index_, other.index_);
 }
 
-Value::CZString& Value::CZString::operator=(const CZString& other) {
-  cstr_ = other.cstr_;
-  index_ = other.index_;
+Value::CZString& Value::CZString::operator=(const CZString& other)
+{
+  this->cstr_ = other.cstr_;
+  this->index_ = other.index_;
   return *this;
 }
 
 #if JSON_HAS_RVALUE_REFERENCES
-Value::CZString& Value::CZString::operator=(CZString&& other) {
-  cstr_ = other.cstr_;
-  index_ = other.index_;
+Value::CZString& Value::CZString::operator=(CZString&& other)
+{
+  this->cstr_ = other.cstr_;
+  this->index_ = other.index_;
   other.cstr_ = nullptr;
   return *this;
 }
 #endif
 
-bool Value::CZString::operator<(const CZString& other) const {
-  if (!cstr_) return index_ < other.index_;
-  //return strcmp(cstr_, other.cstr_) < 0;
+bool Value::CZString::operator<(const CZString& other) const
+{
+  if (!this->cstr_)
+    return this->index_ < other.index_;
+  // return strcmp(cstr_, other.cstr_) < 0;
   // Assume both are strings.
   unsigned this_len = this->storage_.length_;
   unsigned other_len = other.storage_.length_;
   unsigned min_len = std::min<unsigned>(this_len, other_len);
   JSON_ASSERT(this->cstr_ && other.cstr_);
   int comp = memcmp(this->cstr_, other.cstr_, min_len);
-  if (comp < 0) return true;
-  if (comp > 0) return false;
+  if (comp < 0)
+    return true;
+  if (comp > 0)
+    return false;
   return (this_len < other_len);
 }
 
-bool Value::CZString::operator==(const CZString& other) const {
-  if (!cstr_) return index_ == other.index_;
-  //return strcmp(cstr_, other.cstr_) == 0;
+bool Value::CZString::operator==(const CZString& other) const
+{
+  if (!this->cstr_)
+    return this->index_ == other.index_;
+  // return strcmp(cstr_, other.cstr_) == 0;
   // Assume both are strings.
   unsigned this_len = this->storage_.length_;
   unsigned other_len = other.storage_.length_;
-  if (this_len != other_len) return false;
+  if (this_len != other_len)
+    return false;
   JSON_ASSERT(this->cstr_ && other.cstr_);
   int comp = memcmp(this->cstr_, other.cstr_, this_len);
   return comp == 0;
 }
 
-ArrayIndex Value::CZString::index() const { return index_; }
+ArrayIndex Value::CZString::index() const
+{
+  return this->index_;
+}
 
-//const char* Value::CZString::c_str() const { return cstr_; }
-const char* Value::CZString::data() const { return cstr_; }
-unsigned Value::CZString::length() const { return storage_.length_; }
-bool Value::CZString::isStaticString() const { return storage_.policy_ == noDuplication; }
+// const char* Value::CZString::c_str() const { return cstr_; }
+const char* Value::CZString::data() const
+{
+  return this->cstr_;
+}
+unsigned Value::CZString::length() const
+{
+  return this->storage_.length_;
+}
+bool Value::CZString::isStaticString() const
+{
+  return this->storage_.policy_ == noDuplication;
+}
 
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
@@ -352,210 +410,238 @@ bool Value::CZString::isStaticString() const { return storage_.policy_ == noDupl
  * memset( this, 0, sizeof(Value) )
  * This optimization is used in ValueInternalMap fast allocator.
  */
-Value::Value(ValueType vtype) {
+Value::Value(ValueType vtype)
+{
   static char const emptyString[] = "";
-  initBasic(vtype);
+  this->initBasic(vtype);
   switch (vtype) {
-  case nullValue:
-    break;
-  case intValue:
-  case uintValue:
-    value_.int_ = 0;
-    break;
-  case realValue:
-    value_.real_ = 0.0;
-    break;
-  case stringValue:
-    // allocated_ == false, so this is safe.
-    value_.string_ = const_cast<char*>(static_cast<char const*>(emptyString));
-    break;
-  case arrayValue:
-  case objectValue:
-    value_.map_ = new ObjectValues();
-    break;
-  case booleanValue:
-    value_.bool_ = false;
-    break;
-  default:
-    JSON_ASSERT_UNREACHABLE;
+    case nullValue:
+      break;
+    case intValue:
+    case uintValue:
+      this->value_.int_ = 0;
+      break;
+    case realValue:
+      this->value_.real_ = 0.0;
+      break;
+    case stringValue:
+      // allocated_ == false, so this is safe.
+      this->value_.string_ =
+        const_cast<char*>(static_cast<char const*>(emptyString));
+      break;
+    case arrayValue:
+    case objectValue:
+      this->value_.map_ = new ObjectValues();
+      break;
+    case booleanValue:
+      this->value_.bool_ = false;
+      break;
+    default:
+      JSON_ASSERT_UNREACHABLE;
   }
 }
 
-Value::Value(Int value) {
-  initBasic(intValue);
-  value_.int_ = value;
+Value::Value(Int value)
+{
+  this->initBasic(intValue);
+  this->value_.int_ = value;
 }
 
-Value::Value(UInt value) {
-  initBasic(uintValue);
-  value_.uint_ = value;
+Value::Value(UInt value)
+{
+  this->initBasic(uintValue);
+  this->value_.uint_ = value;
 }
 #if defined(JSON_HAS_INT64)
-Value::Value(Int64 value) {
-  initBasic(intValue);
-  value_.int_ = value;
+Value::Value(Int64 value)
+{
+  this->initBasic(intValue);
+  this->value_.int_ = value;
 }
-Value::Value(UInt64 value) {
-  initBasic(uintValue);
-  value_.uint_ = value;
+Value::Value(UInt64 value)
+{
+  this->initBasic(uintValue);
+  this->value_.uint_ = value;
 }
 #endif // defined(JSON_HAS_INT64)
 
-Value::Value(double value) {
-  initBasic(realValue);
-  value_.real_ = value;
+Value::Value(double value)
+{
+  this->initBasic(realValue);
+  this->value_.real_ = value;
 }
 
-Value::Value(const char* value) {
-  initBasic(stringValue, true);
+Value::Value(const char* value)
+{
+  this->initBasic(stringValue, true);
   JSON_ASSERT_MESSAGE(value != NULL, "Null Value Passed to Value Constructor");
-  value_.string_ = duplicateAndPrefixStringValue(value, static_cast<unsigned>(strlen(value)));
+  this->value_.string_ =
+    duplicateAndPrefixStringValue(value, static_cast<unsigned>(strlen(value)));
 }
 
-Value::Value(const char* beginValue, const char* endValue) {
-  initBasic(stringValue, true);
-  value_.string_ =
-      duplicateAndPrefixStringValue(beginValue, static_cast<unsigned>(endValue - beginValue));
+Value::Value(const char* beginValue, const char* endValue)
+{
+  this->initBasic(stringValue, true);
+  this->value_.string_ = duplicateAndPrefixStringValue(
+    beginValue, static_cast<unsigned>(endValue - beginValue));
 }
 
-Value::Value(const JSONCPP_STRING& value) {
-  initBasic(stringValue, true);
-  value_.string_ =
-      duplicateAndPrefixStringValue(value.data(), static_cast<unsigned>(value.length()));
+Value::Value(const JSONCPP_STRING& value)
+{
+  this->initBasic(stringValue, true);
+  this->value_.string_ = duplicateAndPrefixStringValue(
+    value.data(), static_cast<unsigned>(value.length()));
 }
 
-Value::Value(const StaticString& value) {
-  initBasic(stringValue);
-  value_.string_ = const_cast<char*>(value.c_str());
+Value::Value(const StaticString& value)
+{
+  this->initBasic(stringValue);
+  this->value_.string_ = const_cast<char*>(value.c_str());
 }
 
 #ifdef JSON_USE_CPPTL
-Value::Value(const CppTL::ConstString& value) {
+Value::Value(const CppTL::ConstString& value)
+{
   initBasic(stringValue, true);
-  value_.string_ = duplicateAndPrefixStringValue(value, static_cast<unsigned>(value.length()));
+  value_.string_ = duplicateAndPrefixStringValue(
+    value, static_cast<unsigned>(value.length()));
 }
 #endif
 
-Value::Value(bool value) {
-  initBasic(booleanValue);
-  value_.bool_ = value;
+Value::Value(bool value)
+{
+  this->initBasic(booleanValue);
+  this->value_.bool_ = value;
 }
 
 Value::Value(Value const& other)
-    : type_(other.type_), allocated_(false)
-      ,
-      comments_(0), start_(other.start_), limit_(other.limit_)
-{
-  switch (type_) {
-  case nullValue:
-  case intValue:
-  case uintValue:
-  case realValue:
-  case booleanValue:
-    value_ = other.value_;
-    break;
-  case stringValue:
-    if (other.value_.string_ && other.allocated_) {
-      unsigned len;
-      char const* str;
-      decodePrefixedString(other.allocated_, other.value_.string_,
-          &len, &str);
-      value_.string_ = duplicateAndPrefixStringValue(str, len);
-      allocated_ = true;
-    } else {
-      value_.string_ = other.value_.string_;
-      allocated_ = false;
-    }
-    break;
-  case arrayValue:
-  case objectValue:
-    value_.map_ = new ObjectValues(*other.value_.map_);
-    break;
-  default:
-    JSON_ASSERT_UNREACHABLE;
+  : type_(other.type_)
+  , allocated_(false)
+  , comments_(0)
+  , start_(other.start_)
+  , limit_(other.limit_)
+{
+  switch (this->type_) {
+    case nullValue:
+    case intValue:
+    case uintValue:
+    case realValue:
+    case booleanValue:
+      this->value_ = other.value_;
+      break;
+    case stringValue:
+      if (other.value_.string_ && other.allocated_) {
+        unsigned len;
+        char const* str;
+        decodePrefixedString(other.allocated_, other.value_.string_, &len,
+                             &str);
+        this->value_.string_ = duplicateAndPrefixStringValue(str, len);
+        this->allocated_ = true;
+      } else {
+        this->value_.string_ = other.value_.string_;
+        this->allocated_ = false;
+      }
+      break;
+    case arrayValue:
+    case objectValue:
+      this->value_.map_ = new ObjectValues(*other.value_.map_);
+      break;
+    default:
+      JSON_ASSERT_UNREACHABLE;
   }
   if (other.comments_) {
-    comments_ = new CommentInfo[numberOfCommentPlacement];
+    this->comments_ = new CommentInfo[numberOfCommentPlacement];
     for (int comment = 0; comment < numberOfCommentPlacement; ++comment) {
       const CommentInfo& otherComment = other.comments_[comment];
       if (otherComment.comment_)
-        comments_[comment].setComment(
-            otherComment.comment_, strlen(otherComment.comment_));
+        this->comments_[comment].setComment(otherComment.comment_,
+                                            strlen(otherComment.comment_));
     }
   }
 }
 
 #if JSON_HAS_RVALUE_REFERENCES
 // Move constructor
-Value::Value(Value&& other) {
-  initBasic(nullValue);
-  swap(other);
+Value::Value(Value&& other)
+{
+  this->initBasic(nullValue);
+  this->swap(other);
 }
 #endif
 
-Value::~Value() {
-  switch (type_) {
-  case nullValue:
-  case intValue:
-  case uintValue:
-  case realValue:
-  case booleanValue:
-    break;
-  case stringValue:
-    if (allocated_)
-      releasePrefixedStringValue(value_.string_);
-    break;
-  case arrayValue:
-  case objectValue:
-    delete value_.map_;
-    break;
-  default:
-    JSON_ASSERT_UNREACHABLE;
+Value::~Value()
+{
+  switch (this->type_) {
+    case nullValue:
+    case intValue:
+    case uintValue:
+    case realValue:
+    case booleanValue:
+      break;
+    case stringValue:
+      if (this->allocated_)
+        releasePrefixedStringValue(this->value_.string_);
+      break;
+    case arrayValue:
+    case objectValue:
+      delete this->value_.map_;
+      break;
+    default:
+      JSON_ASSERT_UNREACHABLE;
   }
 
-  delete[] comments_;
+  delete[] this->comments_;
 
-  value_.uint_ = 0;
+  this->value_.uint_ = 0;
 }
 
-Value& Value::operator=(Value other) {
-  swap(other);
+Value& Value::operator=(Value other)
+{
+  this->swap(other);
   return *this;
 }
 
-void Value::swapPayload(Value& other) {
-  ValueType temp = type_;
-  type_ = other.type_;
+void Value::swapPayload(Value& other)
+{
+  ValueType temp = this->type_;
+  this->type_ = other.type_;
   other.type_ = temp;
-  std::swap(value_, other.value_);
-  int temp2 = allocated_;
-  allocated_ = other.allocated_;
+  std::swap(this->value_, other.value_);
+  int temp2 = this->allocated_;
+  this->allocated_ = other.allocated_;
   other.allocated_ = temp2 & 0x1;
 }
 
-void Value::copyPayload(const Value& other) {
-  type_ = other.type_;
-  value_ = other.value_;
-  allocated_ = other.allocated_;
+void Value::copyPayload(const Value& other)
+{
+  this->type_ = other.type_;
+  this->value_ = other.value_;
+  this->allocated_ = other.allocated_;
 }
 
-void Value::swap(Value& other) {
-  swapPayload(other);
-  std::swap(comments_, other.comments_);
-  std::swap(start_, other.start_);
-  std::swap(limit_, other.limit_);
+void Value::swap(Value& other)
+{
+  this->swapPayload(other);
+  std::swap(this->comments_, other.comments_);
+  std::swap(this->start_, other.start_);
+  std::swap(this->limit_, other.limit_);
 }
 
-void Value::copy(const Value& other) {
-  copyPayload(other);
-  comments_ = other.comments_;
-  start_ = other.start_;
-  limit_ = other.limit_;
+void Value::copy(const Value& other)
+{
+  this->copyPayload(other);
+  this->comments_ = other.comments_;
+  this->start_ = other.start_;
+  this->limit_ = other.limit_;
 }
 
-ValueType Value::type() const { return type_; }
+ValueType Value::type() const
+{
+  return this->type_;
+}
 
-int Value::compare(const Value& other) const {
+int Value::compare(const Value& other) const
+{
   if (*this < other)
     return -1;
   if (*this > other)
@@ -563,509 +649,568 @@ int Value::compare(const Value& other) const {
   return 0;
 }
 
-bool Value::operator<(const Value& other) const {
-  int typeDelta = type_ - other.type_;
+bool Value::operator<(const Value& other) const
+{
+  int typeDelta = this->type_ - other.type_;
   if (typeDelta)
     return typeDelta < 0 ? true : false;
-  switch (type_) {
-  case nullValue:
-    return false;
-  case intValue:
-    return value_.int_ < other.value_.int_;
-  case uintValue:
-    return value_.uint_ < other.value_.uint_;
-  case realValue:
-    return value_.real_ < other.value_.real_;
-  case booleanValue:
-    return value_.bool_ < other.value_.bool_;
-  case stringValue:
-  {
-    if ((value_.string_ == 0) || (other.value_.string_ == 0)) {
-      if (other.value_.string_) return true;
-      else return false;
+  switch (this->type_) {
+    case nullValue:
+      return false;
+    case intValue:
+      return this->value_.int_ < other.value_.int_;
+    case uintValue:
+      return this->value_.uint_ < other.value_.uint_;
+    case realValue:
+      return this->value_.real_ < other.value_.real_;
+    case booleanValue:
+      return this->value_.bool_ < other.value_.bool_;
+    case stringValue: {
+      if ((this->value_.string_ == 0) || (other.value_.string_ == 0)) {
+        if (other.value_.string_)
+          return true;
+        else
+          return false;
+      }
+      unsigned this_len;
+      unsigned other_len;
+      char const* this_str;
+      char const* other_str;
+      decodePrefixedString(this->allocated_, this->value_.string_, &this_len,
+                           &this_str);
+      decodePrefixedString(other.allocated_, other.value_.string_, &other_len,
+                           &other_str);
+      unsigned min_len = std::min<unsigned>(this_len, other_len);
+      JSON_ASSERT(this_str && other_str);
+      int comp = memcmp(this_str, other_str, min_len);
+      if (comp < 0)
+        return true;
+      if (comp > 0)
+        return false;
+      return (this_len < other_len);
     }
-    unsigned this_len;
-    unsigned other_len;
-    char const* this_str;
-    char const* other_str;
-    decodePrefixedString(this->allocated_, this->value_.string_, &this_len, &this_str);
-    decodePrefixedString(other.allocated_, other.value_.string_, &other_len, &other_str);
-    unsigned min_len = std::min<unsigned>(this_len, other_len);
-    JSON_ASSERT(this_str && other_str);
-    int comp = memcmp(this_str, other_str, min_len);
-    if (comp < 0) return true;
-    if (comp > 0) return false;
-    return (this_len < other_len);
-  }
-  case arrayValue:
-  case objectValue: {
-    int delta = int(value_.map_->size() - other.value_.map_->size());
-    if (delta)
-      return delta < 0;
-    return (*value_.map_) < (*other.value_.map_);
-  }
-  default:
-    JSON_ASSERT_UNREACHABLE;
+    case arrayValue:
+    case objectValue: {
+      int delta = int(this->value_.map_->size() - other.value_.map_->size());
+      if (delta)
+        return delta < 0;
+      return (*this->value_.map_) < (*other.value_.map_);
+    }
+    default:
+      JSON_ASSERT_UNREACHABLE;
   }
   return false; // unreachable
 }
 
-bool Value::operator<=(const Value& other) const { return !(other < *this); }
+bool Value::operator<=(const Value& other) const
+{
+  return !(other < *this);
+}
 
-bool Value::operator>=(const Value& other) const { return !(*this < other); }
+bool Value::operator>=(const Value& other) const
+{
+  return !(*this < other);
+}
 
-bool Value::operator>(const Value& other) const { return other < *this; }
+bool Value::operator>(const Value& other) const
+{
+  return other < *this;
+}
 
-bool Value::operator==(const Value& other) const {
+bool Value::operator==(const Value& other) const
+{
   // if ( type_ != other.type_ )
   // GCC 2.95.3 says:
   // attempt to take address of bit-field structure member `Json::Value::type_'
   // Beats me, but a temp solves the problem.
   int temp = other.type_;
-  if (type_ != temp)
+  if (this->type_ != temp)
     return false;
-  switch (type_) {
-  case nullValue:
-    return true;
-  case intValue:
-    return value_.int_ == other.value_.int_;
-  case uintValue:
-    return value_.uint_ == other.value_.uint_;
-  case realValue:
-    return value_.real_ == other.value_.real_;
-  case booleanValue:
-    return value_.bool_ == other.value_.bool_;
-  case stringValue:
-  {
-    if ((value_.string_ == 0) || (other.value_.string_ == 0)) {
-      return (value_.string_ == other.value_.string_);
+  switch (this->type_) {
+    case nullValue:
+      return true;
+    case intValue:
+      return this->value_.int_ == other.value_.int_;
+    case uintValue:
+      return this->value_.uint_ == other.value_.uint_;
+    case realValue:
+      return this->value_.real_ == other.value_.real_;
+    case booleanValue:
+      return this->value_.bool_ == other.value_.bool_;
+    case stringValue: {
+      if ((this->value_.string_ == 0) || (other.value_.string_ == 0)) {
+        return (this->value_.string_ == other.value_.string_);
+      }
+      unsigned this_len;
+      unsigned other_len;
+      char const* this_str;
+      char const* other_str;
+      decodePrefixedString(this->allocated_, this->value_.string_, &this_len,
+                           &this_str);
+      decodePrefixedString(other.allocated_, other.value_.string_, &other_len,
+                           &other_str);
+      if (this_len != other_len)
+        return false;
+      JSON_ASSERT(this_str && other_str);
+      int comp = memcmp(this_str, other_str, this_len);
+      return comp == 0;
     }
-    unsigned this_len;
-    unsigned other_len;
-    char const* this_str;
-    char const* other_str;
-    decodePrefixedString(this->allocated_, this->value_.string_, &this_len, &this_str);
-    decodePrefixedString(other.allocated_, other.value_.string_, &other_len, &other_str);
-    if (this_len != other_len) return false;
-    JSON_ASSERT(this_str && other_str);
-    int comp = memcmp(this_str, other_str, this_len);
-    return comp == 0;
-  }
-  case arrayValue:
-  case objectValue:
-    return value_.map_->size() == other.value_.map_->size() &&
-           (*value_.map_) == (*other.value_.map_);
-  default:
-    JSON_ASSERT_UNREACHABLE;
+    case arrayValue:
+    case objectValue:
+      return this->value_.map_->size() == other.value_.map_->size() &&
+        (*this->value_.map_) == (*other.value_.map_);
+    default:
+      JSON_ASSERT_UNREACHABLE;
   }
   return false; // unreachable
 }
 
-bool Value::operator!=(const Value& other) const { return !(*this == other); }
+bool Value::operator!=(const Value& other) const
+{
+  return !(*this == other);
+}
 
-const char* Value::asCString() const {
+const char* Value::asCString() const
+{
   JSON_ASSERT_MESSAGE(type_ == stringValue,
                       "in Json::Value::asCString(): requires stringValue");
-  if (value_.string_ == 0) return 0;
+  if (this->value_.string_ == 0)
+    return 0;
   unsigned this_len;
   char const* this_str;
-  decodePrefixedString(this->allocated_, this->value_.string_, &this_len, &this_str);
+  decodePrefixedString(this->allocated_, this->value_.string_, &this_len,
+                       &this_str);
   return this_str;
 }
 
 #if JSONCPP_USING_SECURE_MEMORY
-unsigned Value::getCStringLength() const {
+unsigned Value::getCStringLength() const
+{
   JSON_ASSERT_MESSAGE(type_ == stringValue,
-	                  "in Json::Value::asCString(): requires stringValue");
-  if (value_.string_ == 0) return 0;
+                      "in Json::Value::asCString(): requires stringValue");
+  if (value_.string_ == 0)
+    return 0;
   unsigned this_len;
   char const* this_str;
-  decodePrefixedString(this->allocated_, this->value_.string_, &this_len, &this_str);
+  decodePrefixedString(this->allocated_, this->value_.string_, &this_len,
+                       &this_str);
   return this_len;
 }
 #endif
 
-bool Value::getString(char const** str, char const** cend) const {
-  if (type_ != stringValue) return false;
-  if (value_.string_ == 0) return false;
+bool Value::getString(char const** str, char const** cend) const
+{
+  if (this->type_ != stringValue)
+    return false;
+  if (this->value_.string_ == 0)
+    return false;
   unsigned length;
   decodePrefixedString(this->allocated_, this->value_.string_, &length, str);
   *cend = *str + length;
   return true;
 }
 
-JSONCPP_STRING Value::asString() const {
-  switch (type_) {
-  case nullValue:
-    return "";
-  case stringValue:
-  {
-    if (value_.string_ == 0) return "";
-    unsigned this_len;
-    char const* this_str;
-    decodePrefixedString(this->allocated_, this->value_.string_, &this_len, &this_str);
-    return JSONCPP_STRING(this_str, this_len);
-  }
-  case booleanValue:
-    return value_.bool_ ? "true" : "false";
-  case intValue:
-    return valueToString(value_.int_);
-  case uintValue:
-    return valueToString(value_.uint_);
-  case realValue:
-    return valueToString(value_.real_);
-  default:
-    JSON_FAIL_MESSAGE("Type is not convertible to string");
+JSONCPP_STRING Value::asString() const
+{
+  switch (this->type_) {
+    case nullValue:
+      return "";
+    case stringValue: {
+      if (this->value_.string_ == 0)
+        return "";
+      unsigned this_len;
+      char const* this_str;
+      decodePrefixedString(this->allocated_, this->value_.string_, &this_len,
+                           &this_str);
+      return JSONCPP_STRING(this_str, this_len);
+    }
+    case booleanValue:
+      return this->value_.bool_ ? "true" : "false";
+    case intValue:
+      return valueToString(this->value_.int_);
+    case uintValue:
+      return valueToString(this->value_.uint_);
+    case realValue:
+      return valueToString(this->value_.real_);
+    default:
+      JSON_FAIL_MESSAGE("Type is not convertible to string");
   }
 }
 
 #ifdef JSON_USE_CPPTL
-CppTL::ConstString Value::asConstString() const {
+CppTL::ConstString Value::asConstString() const
+{
   unsigned len;
   char const* str;
-  decodePrefixedString(allocated_, value_.string_,
-      &len, &str);
+  decodePrefixedString(allocated_, value_.string_, &len, &str);
   return CppTL::ConstString(str, len);
 }
 #endif
 
-Value::Int Value::asInt() const {
-  switch (type_) {
-  case intValue:
-    JSON_ASSERT_MESSAGE(isInt(), "LargestInt out of Int range");
-    return Int(value_.int_);
-  case uintValue:
-    JSON_ASSERT_MESSAGE(isInt(), "LargestUInt out of Int range");
-    return Int(value_.uint_);
-  case realValue:
-    JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt, maxInt),
-                        "double out of Int range");
-    return Int(value_.real_);
-  case nullValue:
-    return 0;
-  case booleanValue:
-    return value_.bool_ ? 1 : 0;
-  default:
-    break;
+Value::Int Value::asInt() const
+{
+  switch (this->type_) {
+    case intValue:
+      JSON_ASSERT_MESSAGE(isInt(), "LargestInt out of Int range");
+      return Int(this->value_.int_);
+    case uintValue:
+      JSON_ASSERT_MESSAGE(isInt(), "LargestUInt out of Int range");
+      return Int(this->value_.uint_);
+    case realValue:
+      JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt, maxInt),
+                          "double out of Int range");
+      return Int(this->value_.real_);
+    case nullValue:
+      return 0;
+    case booleanValue:
+      return this->value_.bool_ ? 1 : 0;
+    default:
+      break;
   }
   JSON_FAIL_MESSAGE("Value is not convertible to Int.");
 }
 
-Value::UInt Value::asUInt() const {
-  switch (type_) {
-  case intValue:
-    JSON_ASSERT_MESSAGE(isUInt(), "LargestInt out of UInt range");
-    return UInt(value_.int_);
-  case uintValue:
-    JSON_ASSERT_MESSAGE(isUInt(), "LargestUInt out of UInt range");
-    return UInt(value_.uint_);
-  case realValue:
-    JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt),
-                        "double out of UInt range");
-    return UInt(value_.real_);
-  case nullValue:
-    return 0;
-  case booleanValue:
-    return value_.bool_ ? 1 : 0;
-  default:
-    break;
+Value::UInt Value::asUInt() const
+{
+  switch (this->type_) {
+    case intValue:
+      JSON_ASSERT_MESSAGE(isUInt(), "LargestInt out of UInt range");
+      return UInt(this->value_.int_);
+    case uintValue:
+      JSON_ASSERT_MESSAGE(isUInt(), "LargestUInt out of UInt range");
+      return UInt(this->value_.uint_);
+    case realValue:
+      JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt),
+                          "double out of UInt range");
+      return UInt(this->value_.real_);
+    case nullValue:
+      return 0;
+    case booleanValue:
+      return this->value_.bool_ ? 1 : 0;
+    default:
+      break;
   }
   JSON_FAIL_MESSAGE("Value is not convertible to UInt.");
 }
 
 #if defined(JSON_HAS_INT64)
 
-Value::Int64 Value::asInt64() const {
-  switch (type_) {
-  case intValue:
-    return Int64(value_.int_);
-  case uintValue:
-    JSON_ASSERT_MESSAGE(isInt64(), "LargestUInt out of Int64 range");
-    return Int64(value_.uint_);
-  case realValue:
-    JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt64, maxInt64),
-                        "double out of Int64 range");
-    return Int64(value_.real_);
-  case nullValue:
-    return 0;
-  case booleanValue:
-    return value_.bool_ ? 1 : 0;
-  default:
-    break;
+Value::Int64 Value::asInt64() const
+{
+  switch (this->type_) {
+    case intValue:
+      return Int64(this->value_.int_);
+    case uintValue:
+      JSON_ASSERT_MESSAGE(isInt64(), "LargestUInt out of Int64 range");
+      return Int64(this->value_.uint_);
+    case realValue:
+      JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt64, maxInt64),
+                          "double out of Int64 range");
+      return Int64(this->value_.real_);
+    case nullValue:
+      return 0;
+    case booleanValue:
+      return this->value_.bool_ ? 1 : 0;
+    default:
+      break;
   }
   JSON_FAIL_MESSAGE("Value is not convertible to Int64.");
 }
 
-Value::UInt64 Value::asUInt64() const {
-  switch (type_) {
-  case intValue:
-    JSON_ASSERT_MESSAGE(isUInt64(), "LargestInt out of UInt64 range");
-    return UInt64(value_.int_);
-  case uintValue:
-    return UInt64(value_.uint_);
-  case realValue:
-    JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt64),
-                        "double out of UInt64 range");
-    return UInt64(value_.real_);
-  case nullValue:
-    return 0;
-  case booleanValue:
-    return value_.bool_ ? 1 : 0;
-  default:
-    break;
+Value::UInt64 Value::asUInt64() const
+{
+  switch (this->type_) {
+    case intValue:
+      JSON_ASSERT_MESSAGE(isUInt64(), "LargestInt out of UInt64 range");
+      return UInt64(this->value_.int_);
+    case uintValue:
+      return UInt64(this->value_.uint_);
+    case realValue:
+      JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt64),
+                          "double out of UInt64 range");
+      return UInt64(this->value_.real_);
+    case nullValue:
+      return 0;
+    case booleanValue:
+      return this->value_.bool_ ? 1 : 0;
+    default:
+      break;
   }
   JSON_FAIL_MESSAGE("Value is not convertible to UInt64.");
 }
 #endif // if defined(JSON_HAS_INT64)
 
-LargestInt Value::asLargestInt() const {
+LargestInt Value::asLargestInt() const
+{
 #if defined(JSON_NO_INT64)
   return asInt();
 #else
-  return asInt64();
+  return this->asInt64();
 #endif
 }
 
-LargestUInt Value::asLargestUInt() const {
+LargestUInt Value::asLargestUInt() const
+{
 #if defined(JSON_NO_INT64)
   return asUInt();
 #else
-  return asUInt64();
+  return this->asUInt64();
 #endif
 }
 
-double Value::asDouble() const {
-  switch (type_) {
-  case intValue:
-    return static_cast<double>(value_.int_);
-  case uintValue:
+double Value::asDouble() const
+{
+  switch (this->type_) {
+    case intValue:
+      return static_cast<double>(this->value_.int_);
+    case uintValue:
 #if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
-    return static_cast<double>(value_.uint_);
+      return static_cast<double>(this->value_.uint_);
 #else  // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
-    return integerToDouble(value_.uint_);
+      return integerToDouble(value_.uint_);
 #endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
-  case realValue:
-    return value_.real_;
-  case nullValue:
-    return 0.0;
-  case booleanValue:
-    return value_.bool_ ? 1.0 : 0.0;
-  default:
-    break;
+    case realValue:
+      return this->value_.real_;
+    case nullValue:
+      return 0.0;
+    case booleanValue:
+      return this->value_.bool_ ? 1.0 : 0.0;
+    default:
+      break;
   }
   JSON_FAIL_MESSAGE("Value is not convertible to double.");
 }
 
-float Value::asFloat() const {
-  switch (type_) {
-  case intValue:
-    return static_cast<float>(value_.int_);
-  case uintValue:
+float Value::asFloat() const
+{
+  switch (this->type_) {
+    case intValue:
+      return static_cast<float>(this->value_.int_);
+    case uintValue:
 #if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
-    return static_cast<float>(value_.uint_);
+      return static_cast<float>(this->value_.uint_);
 #else  // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
-    // This can fail (silently?) if the value is bigger than MAX_FLOAT.
-    return static_cast<float>(integerToDouble(value_.uint_));
+      // This can fail (silently?) if the value is bigger than MAX_FLOAT.
+      return static_cast<float>(integerToDouble(value_.uint_));
 #endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
-  case realValue:
-    return static_cast<float>(value_.real_);
-  case nullValue:
-    return 0.0;
-  case booleanValue:
-    return value_.bool_ ? 1.0f : 0.0f;
-  default:
-    break;
+    case realValue:
+      return static_cast<float>(this->value_.real_);
+    case nullValue:
+      return 0.0;
+    case booleanValue:
+      return this->value_.bool_ ? 1.0f : 0.0f;
+    default:
+      break;
   }
   JSON_FAIL_MESSAGE("Value is not convertible to float.");
 }
 
-bool Value::asBool() const {
-  switch (type_) {
-  case booleanValue:
-    return value_.bool_;
-  case nullValue:
-    return false;
-  case intValue:
-    return value_.int_ ? true : false;
-  case uintValue:
-    return value_.uint_ ? true : false;
-  case realValue:
-    // This is kind of strange. Not recommended.
-    return (value_.real_ != 0.0) ? true : false;
-  default:
-    break;
+bool Value::asBool() const
+{
+  switch (this->type_) {
+    case booleanValue:
+      return this->value_.bool_;
+    case nullValue:
+      return false;
+    case intValue:
+      return this->value_.int_ ? true : false;
+    case uintValue:
+      return this->value_.uint_ ? true : false;
+    case realValue:
+      // This is kind of strange. Not recommended.
+      return (this->value_.real_ != 0.0) ? true : false;
+    default:
+      break;
   }
   JSON_FAIL_MESSAGE("Value is not convertible to bool.");
 }
 
-bool Value::isConvertibleTo(ValueType other) const {
+bool Value::isConvertibleTo(ValueType other) const
+{
   switch (other) {
-  case nullValue:
-    return (isNumeric() && asDouble() == 0.0) ||
-           (type_ == booleanValue && value_.bool_ == false) ||
-           (type_ == stringValue && asString().empty()) ||
-           (type_ == arrayValue && value_.map_->size() == 0) ||
-           (type_ == objectValue && value_.map_->size() == 0) ||
-           type_ == nullValue;
-  case intValue:
-    return isInt() ||
-           (type_ == realValue && InRange(value_.real_, minInt, maxInt)) ||
-           type_ == booleanValue || type_ == nullValue;
-  case uintValue:
-    return isUInt() ||
-           (type_ == realValue && InRange(value_.real_, 0, maxUInt)) ||
-           type_ == booleanValue || type_ == nullValue;
-  case realValue:
-    return isNumeric() || type_ == booleanValue || type_ == nullValue;
-  case booleanValue:
-    return isNumeric() || type_ == booleanValue || type_ == nullValue;
-  case stringValue:
-    return isNumeric() || type_ == booleanValue || type_ == stringValue ||
-           type_ == nullValue;
-  case arrayValue:
-    return type_ == arrayValue || type_ == nullValue;
-  case objectValue:
-    return type_ == objectValue || type_ == nullValue;
+    case nullValue:
+      return (this->isNumeric() && this->asDouble() == 0.0) ||
+        (this->type_ == booleanValue && this->value_.bool_ == false) ||
+        (this->type_ == stringValue && this->asString().empty()) ||
+        (this->type_ == arrayValue && this->value_.map_->size() == 0) ||
+        (this->type_ == objectValue && this->value_.map_->size() == 0) ||
+        this->type_ == nullValue;
+    case intValue:
+      return this->isInt() ||
+        (this->type_ == realValue &&
+         InRange(this->value_.real_, minInt, maxInt)) ||
+        this->type_ == booleanValue || this->type_ == nullValue;
+    case uintValue:
+      return this->isUInt() ||
+        (this->type_ == realValue &&
+         InRange(this->value_.real_, 0, maxUInt)) ||
+        this->type_ == booleanValue || this->type_ == nullValue;
+    case realValue:
+      return this->isNumeric() || this->type_ == booleanValue ||
+        this->type_ == nullValue;
+    case booleanValue:
+      return this->isNumeric() || this->type_ == booleanValue ||
+        this->type_ == nullValue;
+    case stringValue:
+      return this->isNumeric() || this->type_ == booleanValue ||
+        this->type_ == stringValue || this->type_ == nullValue;
+    case arrayValue:
+      return this->type_ == arrayValue || this->type_ == nullValue;
+    case objectValue:
+      return this->type_ == objectValue || this->type_ == nullValue;
   }
   JSON_ASSERT_UNREACHABLE;
   return false;
 }
 
 /// Number of values in array or object
-ArrayIndex Value::size() const {
-  switch (type_) {
-  case nullValue:
-  case intValue:
-  case uintValue:
-  case realValue:
-  case booleanValue:
-  case stringValue:
-    return 0;
-  case arrayValue: // size of the array is highest index + 1
-    if (!value_.map_->empty()) {
-      ObjectValues::const_iterator itLast = value_.map_->end();
-      --itLast;
-      return (*itLast).first.index() + 1;
-    }
-    return 0;
-  case objectValue:
-    return ArrayIndex(value_.map_->size());
+ArrayIndex Value::size() const
+{
+  switch (this->type_) {
+    case nullValue:
+    case intValue:
+    case uintValue:
+    case realValue:
+    case booleanValue:
+    case stringValue:
+      return 0;
+    case arrayValue: // size of the array is highest index + 1
+      if (!this->value_.map_->empty()) {
+        ObjectValues::const_iterator itLast = this->value_.map_->end();
+        --itLast;
+        return (*itLast).first.index() + 1;
+      }
+      return 0;
+    case objectValue:
+      return ArrayIndex(this->value_.map_->size());
   }
   JSON_ASSERT_UNREACHABLE;
   return 0; // unreachable;
 }
 
-bool Value::empty() const {
-  if (isNull() || isArray() || isObject())
-    return size() == 0u;
+bool Value::empty() const
+{
+  if (this->isNull() || this->isArray() || this->isObject())
+    return this->size() == 0u;
   else
     return false;
 }
 
-bool Value::operator!() const { return isNull(); }
+bool Value::operator!() const
+{
+  return this->isNull();
+}
 
-void Value::clear() {
+void Value::clear()
+{
   JSON_ASSERT_MESSAGE(type_ == nullValue || type_ == arrayValue ||
-                          type_ == objectValue,
+                        type_ == objectValue,
                       "in Json::Value::clear(): requires complex value");
-  start_ = 0;
-  limit_ = 0;
-  switch (type_) {
-  case arrayValue:
-  case objectValue:
-    value_.map_->clear();
-    break;
-  default:
-    break;
+  this->start_ = 0;
+  this->limit_ = 0;
+  switch (this->type_) {
+    case arrayValue:
+    case objectValue:
+      this->value_.map_->clear();
+      break;
+    default:
+      break;
   }
 }
 
-void Value::resize(ArrayIndex newSize) {
+void Value::resize(ArrayIndex newSize)
+{
   JSON_ASSERT_MESSAGE(type_ == nullValue || type_ == arrayValue,
                       "in Json::Value::resize(): requires arrayValue");
-  if (type_ == nullValue)
+  if (this->type_ == nullValue)
     *this = Value(arrayValue);
-  ArrayIndex oldSize = size();
+  ArrayIndex oldSize = this->size();
   if (newSize == 0)
-    clear();
+    this->clear();
   else if (newSize > oldSize)
     (*this)[newSize - 1];
   else {
     for (ArrayIndex index = newSize; index < oldSize; ++index) {
-      value_.map_->erase(index);
+      this->value_.map_->erase(index);
     }
     JSON_ASSERT(size() == newSize);
   }
 }
 
-Value& Value::operator[](ArrayIndex index) {
+Value& Value::operator[](ArrayIndex index)
+{
   JSON_ASSERT_MESSAGE(
-      type_ == nullValue || type_ == arrayValue,
-      "in Json::Value::operator[](ArrayIndex): requires arrayValue");
-  if (type_ == nullValue)
+    type_ == nullValue || type_ == arrayValue,
+    "in Json::Value::operator[](ArrayIndex): requires arrayValue");
+  if (this->type_ == nullValue)
     *this = Value(arrayValue);
   CZString key(index);
-  ObjectValues::iterator it = value_.map_->lower_bound(key);
-  if (it != value_.map_->end() && (*it).first == key)
+  ObjectValues::iterator it = this->value_.map_->lower_bound(key);
+  if (it != this->value_.map_->end() && (*it).first == key)
     return (*it).second;
 
   ObjectValues::value_type defaultValue(key, nullSingleton());
-  it = value_.map_->insert(it, defaultValue);
+  it = this->value_.map_->insert(it, defaultValue);
   return (*it).second;
 }
 
-Value& Value::operator[](int index) {
+Value& Value::operator[](int index)
+{
   JSON_ASSERT_MESSAGE(
-      index >= 0,
-      "in Json::Value::operator[](int index): index cannot be negative");
+    index >= 0,
+    "in Json::Value::operator[](int index): index cannot be negative");
   return (*this)[ArrayIndex(index)];
 }
 
-const Value& Value::operator[](ArrayIndex index) const {
+const Value& Value::operator[](ArrayIndex index) const
+{
   JSON_ASSERT_MESSAGE(
-      type_ == nullValue || type_ == arrayValue,
-      "in Json::Value::operator[](ArrayIndex)const: requires arrayValue");
-  if (type_ == nullValue)
+    type_ == nullValue || type_ == arrayValue,
+    "in Json::Value::operator[](ArrayIndex)const: requires arrayValue");
+  if (this->type_ == nullValue)
     return nullSingleton();
   CZString key(index);
-  ObjectValues::const_iterator it = value_.map_->find(key);
-  if (it == value_.map_->end())
+  ObjectValues::const_iterator it = this->value_.map_->find(key);
+  if (it == this->value_.map_->end())
     return nullSingleton();
   return (*it).second;
 }
 
-const Value& Value::operator[](int index) const {
+const Value& Value::operator[](int index) const
+{
   JSON_ASSERT_MESSAGE(
-      index >= 0,
-      "in Json::Value::operator[](int index) const: index cannot be negative");
+    index >= 0,
+    "in Json::Value::operator[](int index) const: index cannot be negative");
   return (*this)[ArrayIndex(index)];
 }
 
-void Value::initBasic(ValueType vtype, bool allocated) {
-  type_ = vtype;
-  allocated_ = allocated;
-  comments_ = 0;
-  start_ = 0;
-  limit_ = 0;
+void Value::initBasic(ValueType vtype, bool allocated)
+{
+  this->type_ = vtype;
+  this->allocated_ = allocated;
+  this->comments_ = 0;
+  this->start_ = 0;
+  this->limit_ = 0;
 }
 
 // Access an object value by name, create a null member if it does not exist.
 // @pre Type of '*this' is object or null.
 // @param key is null-terminated.
-Value& Value::resolveReference(const char* key) {
+Value& Value::resolveReference(const char* key)
+{
   JSON_ASSERT_MESSAGE(
-      type_ == nullValue || type_ == objectValue,
-      "in Json::Value::resolveReference(): requires objectValue");
-  if (type_ == nullValue)
+    type_ == nullValue || type_ == objectValue,
+    "in Json::Value::resolveReference(): requires objectValue");
+  if (this->type_ == nullValue)
     *this = Value(objectValue);
-  CZString actualKey(
-      key, static_cast<unsigned>(strlen(key)), CZString::noDuplication); // NOTE!
-  ObjectValues::iterator it = value_.map_->lower_bound(actualKey);
-  if (it != value_.map_->end() && (*it).first == actualKey)
+  CZString actualKey(key, static_cast<unsigned>(strlen(key)),
+                     CZString::noDuplication); // NOTE!
+  ObjectValues::iterator it = this->value_.map_->lower_bound(actualKey);
+  if (it != this->value_.map_->end() && (*it).first == actualKey)
     return (*it).second;
 
   ObjectValues::value_type defaultValue(actualKey, nullSingleton());
-  it = value_.map_->insert(it, defaultValue);
+  it = this->value_.map_->insert(it, defaultValue);
   Value& value = (*it).second;
   return value;
 }
@@ -1074,198 +1219,223 @@ Value& Value::resolveReference(const char* key) {
 Value& Value::resolveReference(char const* key, char const* cend)
 {
   JSON_ASSERT_MESSAGE(
-      type_ == nullValue || type_ == objectValue,
-      "in Json::Value::resolveReference(key, end): requires objectValue");
-  if (type_ == nullValue)
+    type_ == nullValue || type_ == objectValue,
+    "in Json::Value::resolveReference(key, end): requires objectValue");
+  if (this->type_ == nullValue)
     *this = Value(objectValue);
-  CZString actualKey(
-      key, static_cast<unsigned>(cend-key), CZString::duplicateOnCopy);
-  ObjectValues::iterator it = value_.map_->lower_bound(actualKey);
-  if (it != value_.map_->end() && (*it).first == actualKey)
+  CZString actualKey(key, static_cast<unsigned>(cend - key),
+                     CZString::duplicateOnCopy);
+  ObjectValues::iterator it = this->value_.map_->lower_bound(actualKey);
+  if (it != this->value_.map_->end() && (*it).first == actualKey)
     return (*it).second;
 
   ObjectValues::value_type defaultValue(actualKey, nullSingleton());
-  it = value_.map_->insert(it, defaultValue);
+  it = this->value_.map_->insert(it, defaultValue);
   Value& value = (*it).second;
   return value;
 }
 
-Value Value::get(ArrayIndex index, const Value& defaultValue) const {
+Value Value::get(ArrayIndex index, const Value& defaultValue) const
+{
   const Value* value = &((*this)[index]);
   return value == &nullSingleton() ? defaultValue : *value;
 }
 
-bool Value::isValidIndex(ArrayIndex index) const { return index < size(); }
+bool Value::isValidIndex(ArrayIndex index) const
+{
+  return index < this->size();
+}
 
 Value const* Value::find(char const* key, char const* cend) const
 {
-  JSON_ASSERT_MESSAGE(
-      type_ == nullValue || type_ == objectValue,
-      "in Json::Value::find(key, end, found): requires objectValue or nullValue");
-  if (type_ == nullValue) return NULL;
-  CZString actualKey(key, static_cast<unsigned>(cend-key), CZString::noDuplication);
-  ObjectValues::const_iterator it = value_.map_->find(actualKey);
-  if (it == value_.map_->end()) return NULL;
+  JSON_ASSERT_MESSAGE(type_ == nullValue || type_ == objectValue,
+                      "in Json::Value::find(key, end, found): requires "
+                      "objectValue or nullValue");
+  if (this->type_ == nullValue)
+    return NULL;
+  CZString actualKey(key, static_cast<unsigned>(cend - key),
+                     CZString::noDuplication);
+  ObjectValues::const_iterator it = this->value_.map_->find(actualKey);
+  if (it == this->value_.map_->end())
+    return NULL;
   return &(*it).second;
 }
 const Value& Value::operator[](const char* key) const
 {
-  Value const* found = find(key, key + strlen(key));
-  if (!found) return nullSingleton();
+  Value const* found = this->find(key, key + strlen(key));
+  if (!found)
+    return nullSingleton();
   return *found;
 }
 Value const& Value::operator[](JSONCPP_STRING const& key) const
 {
-  Value const* found = find(key.data(), key.data() + key.length());
-  if (!found) return nullSingleton();
+  Value const* found = this->find(key.data(), key.data() + key.length());
+  if (!found)
+    return nullSingleton();
   return *found;
 }
 
-Value& Value::operator[](const char* key) {
-  return resolveReference(key, key + strlen(key));
+Value& Value::operator[](const char* key)
+{
+  return this->resolveReference(key, key + strlen(key));
 }
 
-Value& Value::operator[](const JSONCPP_STRING& key) {
-  return resolveReference(key.data(), key.data() + key.length());
+Value& Value::operator[](const JSONCPP_STRING& key)
+{
+  return this->resolveReference(key.data(), key.data() + key.length());
 }
 
-Value& Value::operator[](const StaticString& key) {
-  return resolveReference(key.c_str());
+Value& Value::operator[](const StaticString& key)
+{
+  return this->resolveReference(key.c_str());
 }
 
 #ifdef JSON_USE_CPPTL
-Value& Value::operator[](const CppTL::ConstString& key) {
+Value& Value::operator[](const CppTL::ConstString& key)
+{
   return resolveReference(key.c_str(), key.end_c_str());
 }
 Value const& Value::operator[](CppTL::ConstString const& key) const
 {
   Value const* found = find(key.c_str(), key.end_c_str());
-  if (!found) return nullSingleton();
+  if (!found)
+    return nullSingleton();
   return *found;
 }
 #endif
 
-Value& Value::append(const Value& value) { return (*this)[size()] = value; }
+Value& Value::append(const Value& value)
+{
+  return (*this)[this->size()] = value;
+}
 
 #if JSON_HAS_RVALUE_REFERENCES
-  Value& Value::append(Value&& value) { return (*this)[size()] = value; }
+Value& Value::append(Value&& value)
+{
+  return (*this)[this->size()] = value;
+}
 #endif
 
-Value Value::get(char const* key, char const* cend, Value const& defaultValue) const
+Value Value::get(char const* key, char const* cend,
+                 Value const& defaultValue) const
 {
-  Value const* found = find(key, cend);
+  Value const* found = this->find(key, cend);
   return !found ? defaultValue : *found;
 }
 Value Value::get(char const* key, Value const& defaultValue) const
 {
-  return get(key, key + strlen(key), defaultValue);
+  return this->get(key, key + strlen(key), defaultValue);
 }
 Value Value::get(JSONCPP_STRING const& key, Value const& defaultValue) const
 {
-  return get(key.data(), key.data() + key.length(), defaultValue);
+  return this->get(key.data(), key.data() + key.length(), defaultValue);
 }
 
-
 bool Value::removeMember(const char* key, const char* cend, Value* removed)
 {
-  if (type_ != objectValue) {
+  if (this->type_ != objectValue) {
     return false;
   }
-  CZString actualKey(key, static_cast<unsigned>(cend-key), CZString::noDuplication);
-  ObjectValues::iterator it = value_.map_->find(actualKey);
-  if (it == value_.map_->end())
+  CZString actualKey(key, static_cast<unsigned>(cend - key),
+                     CZString::noDuplication);
+  ObjectValues::iterator it = this->value_.map_->find(actualKey);
+  if (it == this->value_.map_->end())
     return false;
   *removed = it->second;
-  value_.map_->erase(it);
+  this->value_.map_->erase(it);
   return true;
 }
 bool Value::removeMember(const char* key, Value* removed)
 {
-  return removeMember(key, key + strlen(key), removed);
+  return this->removeMember(key, key + strlen(key), removed);
 }
 bool Value::removeMember(JSONCPP_STRING const& key, Value* removed)
 {
-  return removeMember(key.data(), key.data() + key.length(), removed);
+  return this->removeMember(key.data(), key.data() + key.length(), removed);
 }
 Value Value::removeMember(const char* key)
 {
   JSON_ASSERT_MESSAGE(type_ == nullValue || type_ == objectValue,
                       "in Json::Value::removeMember(): requires objectValue");
-  if (type_ == nullValue)
+  if (this->type_ == nullValue)
     return nullSingleton();
 
-  Value removed;  // null
-  removeMember(key, key + strlen(key), &removed);
+  Value removed; // null
+  this->removeMember(key, key + strlen(key), &removed);
   return removed; // still null if removeMember() did nothing
 }
 Value Value::removeMember(const JSONCPP_STRING& key)
 {
-  return removeMember(key.c_str());
+  return this->removeMember(key.c_str());
 }
 
-bool Value::removeIndex(ArrayIndex index, Value* removed) {
-  if (type_ != arrayValue) {
+bool Value::removeIndex(ArrayIndex index, Value* removed)
+{
+  if (this->type_ != arrayValue) {
     return false;
   }
   CZString key(index);
-  ObjectValues::iterator it = value_.map_->find(key);
-  if (it == value_.map_->end()) {
+  ObjectValues::iterator it = this->value_.map_->find(key);
+  if (it == this->value_.map_->end()) {
     return false;
   }
   *removed = it->second;
-  ArrayIndex oldSize = size();
+  ArrayIndex oldSize = this->size();
   // shift left all items left, into the place of the "removed"
-  for (ArrayIndex i = index; i < (oldSize - 1); ++i){
+  for (ArrayIndex i = index; i < (oldSize - 1); ++i) {
     CZString keey(i);
-    (*value_.map_)[keey] = (*this)[i + 1];
+    (*this->value_.map_)[keey] = (*this)[i + 1];
   }
   // erase the last one ("leftover")
   CZString keyLast(oldSize - 1);
-  ObjectValues::iterator itLast = value_.map_->find(keyLast);
-  value_.map_->erase(itLast);
+  ObjectValues::iterator itLast = this->value_.map_->find(keyLast);
+  this->value_.map_->erase(itLast);
   return true;
 }
 
 #ifdef JSON_USE_CPPTL
 Value Value::get(const CppTL::ConstString& key,
-                 const Value& defaultValue) const {
+                 const Value& defaultValue) const
+{
   return get(key.c_str(), key.end_c_str(), defaultValue);
 }
 #endif
 
 bool Value::isMember(char const* key, char const* cend) const
 {
-  Value const* value = find(key, cend);
+  Value const* value = this->find(key, cend);
   return NULL != value;
 }
 bool Value::isMember(char const* key) const
 {
-  return isMember(key, key + strlen(key));
+  return this->isMember(key, key + strlen(key));
 }
 bool Value::isMember(JSONCPP_STRING const& key) const
 {
-  return isMember(key.data(), key.data() + key.length());
+  return this->isMember(key.data(), key.data() + key.length());
 }
 
 #ifdef JSON_USE_CPPTL
-bool Value::isMember(const CppTL::ConstString& key) const {
+bool Value::isMember(const CppTL::ConstString& key) const
+{
   return isMember(key.c_str(), key.end_c_str());
 }
 #endif
 
-Value::Members Value::getMemberNames() const {
+Value::Members Value::getMemberNames() const
+{
   JSON_ASSERT_MESSAGE(
-      type_ == nullValue || type_ == objectValue,
-      "in Json::Value::getMemberNames(), value must be objectValue");
-  if (type_ == nullValue)
+    type_ == nullValue || type_ == objectValue,
+    "in Json::Value::getMemberNames(), value must be objectValue");
+  if (this->type_ == nullValue)
     return Value::Members();
   Members members;
-  members.reserve(value_.map_->size());
-  ObjectValues::const_iterator it = value_.map_->begin();
-  ObjectValues::const_iterator itEnd = value_.map_->end();
+  members.reserve(this->value_.map_->size());
+  ObjectValues::const_iterator it = this->value_.map_->begin();
+  ObjectValues::const_iterator itEnd = this->value_.map_->end();
   for (; it != itEnd; ++it) {
-    members.push_back(JSONCPP_STRING((*it).first.data(),
-                                  (*it).first.length()));
+    members.push_back(
+      JSONCPP_STRING((*it).first.data(), (*it).first.length()));
   }
   return members;
 }
@@ -1277,8 +1447,8 @@ Value::Members Value::getMemberNames() const {
 //   if ( type_ == objectValue )
 //   {
 //      return CppTL::Enum::any(  CppTL::Enum::transform(
-//         CppTL::Enum::keys( *(value_.map_), CppTL::Type<const CZString &>() ),
-//         MemberNamesTransform() ) );
+//         CppTL::Enum::keys( *(value_.map_), CppTL::Type<const CZString &>()
+//         ), MemberNamesTransform() ) );
 //   }
 //   return EnumMemberNames();
 //}
@@ -1295,99 +1465,114 @@ Value::Members Value::getMemberNames() const {
 //
 //# endif
 
-static bool IsIntegral(double d) {
+static bool IsIntegral(double d)
+{
   double integral_part;
   return modf(d, &integral_part) == 0.0;
 }
 
-bool Value::isNull() const { return type_ == nullValue; }
+bool Value::isNull() const
+{
+  return this->type_ == nullValue;
+}
 
-bool Value::isBool() const { return type_ == booleanValue; }
+bool Value::isBool() const
+{
+  return this->type_ == booleanValue;
+}
 
-bool Value::isInt() const {
-  switch (type_) {
-  case intValue:
+bool Value::isInt() const
+{
+  switch (this->type_) {
+    case intValue:
 #if defined(JSON_HAS_INT64)
-    return value_.int_ >= minInt && value_.int_ <= maxInt;
+      return this->value_.int_ >= minInt && this->value_.int_ <= maxInt;
 #else
-    return true;
+      return true;
 #endif
-  case uintValue:
-    return value_.uint_ <= UInt(maxInt);
-  case realValue:
-    return value_.real_ >= minInt && value_.real_ <= maxInt &&
-           IsIntegral(value_.real_);
-  default:
-    break;
+    case uintValue:
+      return this->value_.uint_ <= UInt(maxInt);
+    case realValue:
+      return this->value_.real_ >= minInt && this->value_.real_ <= maxInt &&
+        IsIntegral(this->value_.real_);
+    default:
+      break;
   }
   return false;
 }
 
-bool Value::isUInt() const {
-  switch (type_) {
-  case intValue:
+bool Value::isUInt() const
+{
+  switch (this->type_) {
+    case intValue:
 #if defined(JSON_HAS_INT64)
-    return value_.int_ >= 0 && LargestUInt(value_.int_) <= LargestUInt(maxUInt);
+      return this->value_.int_ >= 0 &&
+        LargestUInt(this->value_.int_) <= LargestUInt(maxUInt);
 #else
-    return value_.int_ >= 0;
+      return value_.int_ >= 0;
 #endif
-  case uintValue:
+    case uintValue:
 #if defined(JSON_HAS_INT64)
-    return value_.uint_ <= maxUInt;
+      return this->value_.uint_ <= maxUInt;
 #else
-    return true;
+      return true;
 #endif
-  case realValue:
-    return value_.real_ >= 0 && value_.real_ <= maxUInt &&
-           IsIntegral(value_.real_);
-  default:
-    break;
+    case realValue:
+      return this->value_.real_ >= 0 && this->value_.real_ <= maxUInt &&
+        IsIntegral(this->value_.real_);
+    default:
+      break;
   }
   return false;
 }
 
-bool Value::isInt64() const {
+bool Value::isInt64() const
+{
 #if defined(JSON_HAS_INT64)
-  switch (type_) {
-  case intValue:
-    return true;
-  case uintValue:
-    return value_.uint_ <= UInt64(maxInt64);
-  case realValue:
-    // Note that maxInt64 (= 2^63 - 1) is not exactly representable as a
-    // double, so double(maxInt64) will be rounded up to 2^63. Therefore we
-    // require the value to be strictly less than the limit.
-    return value_.real_ >= double(minInt64) &&
-           value_.real_ < double(maxInt64) && IsIntegral(value_.real_);
-  default:
-    break;
+  switch (this->type_) {
+    case intValue:
+      return true;
+    case uintValue:
+      return this->value_.uint_ <= UInt64(maxInt64);
+    case realValue:
+      // Note that maxInt64 (= 2^63 - 1) is not exactly representable as a
+      // double, so double(maxInt64) will be rounded up to 2^63. Therefore we
+      // require the value to be strictly less than the limit.
+      return this->value_.real_ >= double(minInt64) &&
+        this->value_.real_ < double(maxInt64) &&
+        IsIntegral(this->value_.real_);
+    default:
+      break;
   }
 #endif // JSON_HAS_INT64
   return false;
 }
 
-bool Value::isUInt64() const {
+bool Value::isUInt64() const
+{
 #if defined(JSON_HAS_INT64)
-  switch (type_) {
-  case intValue:
-    return value_.int_ >= 0;
-  case uintValue:
-    return true;
-  case realValue:
-    // Note that maxUInt64 (= 2^64 - 1) is not exactly representable as a
-    // double, so double(maxUInt64) will be rounded up to 2^64. Therefore we
-    // require the value to be strictly less than the limit.
-    return value_.real_ >= 0 && value_.real_ < maxUInt64AsDouble &&
-           IsIntegral(value_.real_);
-  default:
-    break;
+  switch (this->type_) {
+    case intValue:
+      return this->value_.int_ >= 0;
+    case uintValue:
+      return true;
+    case realValue:
+      // Note that maxUInt64 (= 2^64 - 1) is not exactly representable as a
+      // double, so double(maxUInt64) will be rounded up to 2^64. Therefore we
+      // require the value to be strictly less than the limit.
+      return this->value_.real_ >= 0 &&
+        this->value_.real_ < maxUInt64AsDouble &&
+        IsIntegral(this->value_.real_);
+    default:
+      break;
   }
 #endif // JSON_HAS_INT64
   return false;
 }
 
-bool Value::isIntegral() const {
-  switch (type_) {
+bool Value::isIntegral() const
+{
+  switch (this->type_) {
     case intValue:
     case uintValue:
       return true;
@@ -1396,9 +1581,12 @@ bool Value::isIntegral() const {
       // Note that maxUInt64 (= 2^64 - 1) is not exactly representable as a
       // double, so double(maxUInt64) will be rounded up to 2^64. Therefore we
       // require the value to be strictly less than the limit.
-      return value_.real_ >= double(minInt64) && value_.real_ < maxUInt64AsDouble && IsIntegral(value_.real_);
+      return this->value_.real_ >= double(minInt64) &&
+        this->value_.real_ < maxUInt64AsDouble &&
+        IsIntegral(this->value_.real_);
 #else
-      return value_.real_ >= minInt && value_.real_ <= maxUInt && IsIntegral(value_.real_);
+      return value_.real_ >= minInt && value_.real_ <= maxUInt &&
+        IsIntegral(value_.real_);
 #endif // JSON_HAS_INT64
     default:
       break;
@@ -1406,53 +1594,89 @@ bool Value::isIntegral() const {
   return false;
 }
 
-bool Value::isDouble() const { return type_ == intValue || type_ == uintValue || type_ == realValue; }
+bool Value::isDouble() const
+{
+  return this->type_ == intValue || this->type_ == uintValue ||
+    this->type_ == realValue;
+}
 
-bool Value::isNumeric() const { return isDouble(); }
+bool Value::isNumeric() const
+{
+  return this->isDouble();
+}
 
-bool Value::isString() const { return type_ == stringValue; }
+bool Value::isString() const
+{
+  return this->type_ == stringValue;
+}
 
-bool Value::isArray() const { return type_ == arrayValue; }
+bool Value::isArray() const
+{
+  return this->type_ == arrayValue;
+}
 
-bool Value::isObject() const { return type_ == objectValue; }
+bool Value::isObject() const
+{
+  return this->type_ == objectValue;
+}
 
-void Value::setComment(const char* comment, size_t len, CommentPlacement placement) {
-  if (!comments_)
-    comments_ = new CommentInfo[numberOfCommentPlacement];
-  if ((len > 0) && (comment[len-1] == '\n')) {
+void Value::setComment(const char* comment, size_t len,
+                       CommentPlacement placement)
+{
+  if (!this->comments_)
+    this->comments_ = new CommentInfo[numberOfCommentPlacement];
+  if ((len > 0) && (comment[len - 1] == '\n')) {
     // Always discard trailing newline, to aid indentation.
     len -= 1;
   }
-  comments_[placement].setComment(comment, len);
+  this->comments_[placement].setComment(comment, len);
 }
 
-void Value::setComment(const char* comment, CommentPlacement placement) {
-  setComment(comment, strlen(comment), placement);
+void Value::setComment(const char* comment, CommentPlacement placement)
+{
+  this->setComment(comment, strlen(comment), placement);
 }
 
-void Value::setComment(const JSONCPP_STRING& comment, CommentPlacement placement) {
-  setComment(comment.c_str(), comment.length(), placement);
+void Value::setComment(const JSONCPP_STRING& comment,
+                       CommentPlacement placement)
+{
+  this->setComment(comment.c_str(), comment.length(), placement);
 }
 
-bool Value::hasComment(CommentPlacement placement) const {
-  return comments_ != 0 && comments_[placement].comment_ != 0;
+bool Value::hasComment(CommentPlacement placement) const
+{
+  return this->comments_ != 0 && this->comments_[placement].comment_ != 0;
 }
 
-JSONCPP_STRING Value::getComment(CommentPlacement placement) const {
-  if (hasComment(placement))
-    return comments_[placement].comment_;
+JSONCPP_STRING Value::getComment(CommentPlacement placement) const
+{
+  if (this->hasComment(placement))
+    return this->comments_[placement].comment_;
   return "";
 }
 
-void Value::setOffsetStart(ptrdiff_t start) { start_ = start; }
+void Value::setOffsetStart(ptrdiff_t start)
+{
+  this->start_ = start;
+}
 
-void Value::setOffsetLimit(ptrdiff_t limit) { limit_ = limit; }
+void Value::setOffsetLimit(ptrdiff_t limit)
+{
+  this->limit_ = limit;
+}
 
-ptrdiff_t Value::getOffsetStart() const { return start_; }
+ptrdiff_t Value::getOffsetStart() const
+{
+  return this->start_;
+}
 
-ptrdiff_t Value::getOffsetLimit() const { return limit_; }
+ptrdiff_t Value::getOffsetLimit() const
+{
+  return this->limit_;
+}
 
-JSONCPP_STRING Value::toStyledString() const {
+JSONCPP_STRING Value::toStyledString() const
+{
   StreamWriterBuilder builder;
 
   JSONCPP_STRING out = this->hasComment(commentBefore) ? "\n" : "";
@@ -1462,54 +1686,58 @@ JSONCPP_STRING Value::toStyledString() const {
   return out;
 }
 
-Value::const_iterator Value::begin() const {
-  switch (type_) {
-  case arrayValue:
-  case objectValue:
-    if (value_.map_)
-      return const_iterator(value_.map_->begin());
-    break;
-  default:
-    break;
+Value::const_iterator Value::begin() const
+{
+  switch (this->type_) {
+    case arrayValue:
+    case objectValue:
+      if (this->value_.map_)
+        return const_iterator(this->value_.map_->begin());
+      break;
+    default:
+      break;
   }
   return const_iterator();
 }
 
-Value::const_iterator Value::end() const {
-  switch (type_) {
-  case arrayValue:
-  case objectValue:
-    if (value_.map_)
-      return const_iterator(value_.map_->end());
-    break;
-  default:
-    break;
+Value::const_iterator Value::end() const
+{
+  switch (this->type_) {
+    case arrayValue:
+    case objectValue:
+      if (this->value_.map_)
+        return const_iterator(this->value_.map_->end());
+      break;
+    default:
+      break;
   }
   return const_iterator();
 }
 
-Value::iterator Value::begin() {
-  switch (type_) {
-  case arrayValue:
-  case objectValue:
-    if (value_.map_)
-      return iterator(value_.map_->begin());
-    break;
-  default:
-    break;
+Value::iterator Value::begin()
+{
+  switch (this->type_) {
+    case arrayValue:
+    case objectValue:
+      if (this->value_.map_)
+        return iterator(this->value_.map_->begin());
+      break;
+    default:
+      break;
   }
   return iterator();
 }
 
-Value::iterator Value::end() {
-  switch (type_) {
-  case arrayValue:
-  case objectValue:
-    if (value_.map_)
-      return iterator(value_.map_->end());
-    break;
-  default:
-    break;
+Value::iterator Value::end()
+{
+  switch (this->type_) {
+    case arrayValue:
+    case objectValue:
+      if (this->value_.map_)
+        return iterator(this->value_.map_->end());
+      break;
+    default:
+      break;
   }
   return iterator();
 }
@@ -1517,26 +1745,41 @@ Value::iterator Value::end() {
 // class PathArgument
 // //////////////////////////////////////////////////////////////////
 
-PathArgument::PathArgument() : key_(), index_(), kind_(kindNone) {}
+PathArgument::PathArgument()
+  : key_()
+  , index_()
+  , kind_(kindNone)
+{
+}
 
 PathArgument::PathArgument(ArrayIndex index)
-    : key_(), index_(index), kind_(kindIndex) {}
+  : key_()
+  , index_(index)
+  , kind_(kindIndex)
+{
+}
 
 PathArgument::PathArgument(const char* key)
-    : key_(key), index_(), kind_(kindKey) {}
+  : key_(key)
+  , index_()
+  , kind_(kindKey)
+{
+}
 
 PathArgument::PathArgument(const JSONCPP_STRING& key)
-    : key_(key.c_str()), index_(), kind_(kindKey) {}
+  : key_(key.c_str())
+  , index_()
+  , kind_(kindKey)
+{
+}
 
 // class Path
 // //////////////////////////////////////////////////////////////////
 
-Path::Path(const JSONCPP_STRING& path,
-           const PathArgument& a1,
-           const PathArgument& a2,
-           const PathArgument& a3,
-           const PathArgument& a4,
-           const PathArgument& a5) {
+Path::Path(const JSONCPP_STRING& path, const PathArgument& a1,
+           const PathArgument& a2, const PathArgument& a3,
+           const PathArgument& a4, const PathArgument& a5)
+{
   InArgs in;
   in.reserve(5);
   in.push_back(&a1);
@@ -1544,10 +1787,11 @@ Path::Path(const JSONCPP_STRING& path,
   in.push_back(&a3);
   in.push_back(&a4);
   in.push_back(&a5);
-  makePath(path, in);
+  this->makePath(path, in);
 }
 
-void Path::makePath(const JSONCPP_STRING& path, const InArgs& in) {
+void Path::makePath(const JSONCPP_STRING& path, const InArgs& in)
+{
   const char* current = path.c_str();
   const char* end = current + path.length();
   InArgs::const_iterator itInArg = in.begin();
@@ -1555,17 +1799,17 @@ void Path::makePath(const JSONCPP_STRING& path, const InArgs& in) {
     if (*current == '[') {
       ++current;
       if (*current == '%')
-        addPathInArg(path, in, itInArg, PathArgument::kindIndex);
+        this->addPathInArg(path, in, itInArg, PathArgument::kindIndex);
       else {
         ArrayIndex index = 0;
         for (; current != end && *current >= '0' && *current <= '9'; ++current)
           index = index * 10 + ArrayIndex(*current - '0');
-        args_.push_back(index);
+        this->args_.push_back(index);
       }
       if (current == end || *++current != ']')
-        invalidPath(path, int(current - path.c_str()));
+        this->invalidPath(path, int(current - path.c_str()));
     } else if (*current == '%') {
-      addPathInArg(path, in, itInArg, PathArgument::kindKey);
+      this->addPathInArg(path, in, itInArg, PathArgument::kindKey);
       ++current;
     } else if (*current == '.' || *current == ']') {
       ++current;
@@ -1573,31 +1817,34 @@ void Path::makePath(const JSONCPP_STRING& path, const InArgs& in) {
       const char* beginName = current;
       while (current != end && !strchr("[.", *current))
         ++current;
-      args_.push_back(JSONCPP_STRING(beginName, current));
+      this->args_.push_back(JSONCPP_STRING(beginName, current));
     }
   }
 }
 
-void Path::addPathInArg(const JSONCPP_STRING& /*path*/,
-                        const InArgs& in,
+void Path::addPathInArg(const JSONCPP_STRING& /*path*/, const InArgs& in,
                         InArgs::const_iterator& itInArg,
-                        PathArgument::Kind kind) {
+                        PathArgument::Kind kind)
+{
   if (itInArg == in.end()) {
     // Error: missing argument %d
   } else if ((*itInArg)->kind_ != kind) {
     // Error: bad argument type
   } else {
-    args_.push_back(**itInArg++);
+    this->args_.push_back(**itInArg++);
   }
 }
 
-void Path::invalidPath(const JSONCPP_STRING& /*path*/, int /*location*/) {
+void Path::invalidPath(const JSONCPP_STRING& /*path*/, int /*location*/)
+{
   // Error: invalid path.
 }
 
-const Value& Path::resolve(const Value& root) const {
+const Value& Path::resolve(const Value& root) const
+{
   const Value* node = &root;
-  for (Args::const_iterator it = args_.begin(); it != args_.end(); ++it) {
+  for (Args::const_iterator it = this->args_.begin(); it != this->args_.end();
+       ++it) {
     const PathArgument& arg = *it;
     if (arg.kind_ == PathArgument::kindIndex) {
       if (!node->isArray() || !node->isValidIndex(arg.index_)) {
@@ -1621,9 +1868,11 @@ const Value& Path::resolve(const Value& root) const {
   return *node;
 }
 
-Value Path::resolve(const Value& root, const Value& defaultValue) const {
+Value Path::resolve(const Value& root, const Value& defaultValue) const
+{
   const Value* node = &root;
-  for (Args::const_iterator it = args_.begin(); it != args_.end(); ++it) {
+  for (Args::const_iterator it = this->args_.begin(); it != this->args_.end();
+       ++it) {
     const PathArgument& arg = *it;
     if (arg.kind_ == PathArgument::kindIndex) {
       if (!node->isArray() || !node->isValidIndex(arg.index_))
@@ -1640,9 +1889,11 @@ Value Path::resolve(const Value& root, const Value& defaultValue) const {
   return *node;
 }
 
-Value& Path::make(Value& root) const {
+Value& Path::make(Value& root) const
+{
   Value* node = &root;
-  for (Args::const_iterator it = args_.begin(); it != args_.end(); ++it) {
+  for (Args::const_iterator it = this->args_.begin(); it != this->args_.end();
+       ++it) {
     const PathArgument& arg = *it;
     if (arg.kind_ == PathArgument::kindIndex) {
       if (!node->isArray()) {
diff --git a/Utilities/cmjsoncpp/src/lib_json/json_writer.cpp b/Utilities/cmjsoncpp/src/lib_json/json_writer.cpp
index fc86505983..803cfab019 100644
--- a/Utilities/cmjsoncpp/src/lib_json/json_writer.cpp
+++ b/Utilities/cmjsoncpp/src/lib_json/json_writer.cpp
@@ -1,111 +1,115 @@
 // Copyright 2011 Baptiste Lepilleur and The JsonCpp Authors
 // Distributed under MIT license, or public domain if desired and
 // recognized in your jurisdiction.
-// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+// See file LICENSE for detail or copy at
+// http://jsoncpp.sourceforge.net/LICENSE
 
 #if !defined(JSON_IS_AMALGAMATION)
-#include <json/writer.h>
-#include "json_tool.h"
+#  include <json/writer.h>
+
+#  include "json_tool.h"
 #endif // if !defined(JSON_IS_AMALGAMATION)
+#include <cassert>
+#include <cstdio>
+#include <cstring>
 #include <iomanip>
 #include <memory>
+#include <set>
 #include <sstream>
 #include <utility>
-#include <set>
-#include <cassert>
-#include <cstring>
-#include <cstdio>
 
-#if defined(_MSC_VER) && _MSC_VER >= 1200 && _MSC_VER < 1800 // Between VC++ 6.0 and VC++ 11.0
-#include <float.h>
-#define isfinite _finite
-#elif defined(__sun) && defined(__SVR4) //Solaris
-#if !defined(isfinite)
-#include <ieeefp.h>
-#define isfinite finite
-#endif
+#if defined(_MSC_VER) && _MSC_VER >= 1200 &&                                  \
+  _MSC_VER < 1800 // Between VC++ 6.0 and VC++ 11.0
+#  include <float.h>
+#  define isfinite _finite
+#elif defined(__sun) && defined(__SVR4) // Solaris
+#  if !defined(isfinite)
+#    include <ieeefp.h>
+#    define isfinite finite
+#  endif
 #elif defined(_AIX)
-#if !defined(isfinite)
-#include <math.h>
-#define isfinite finite
-#endif
+#  if !defined(isfinite)
+#    include <math.h>
+#    define isfinite finite
+#  endif
 #elif defined(__hpux)
-#if !defined(isfinite) && !defined(__GNUC__)
-#if defined(__ia64) && !defined(finite)
-#define isfinite(x) ((sizeof(x) == sizeof(float) ? \
-                     _Isfinitef(x) : _IsFinite(x)))
-#else
-#include <math.h>
-#define isfinite finite
-#endif
-#endif
+#  if !defined(isfinite) && !defined(__GNUC__)
+#    if defined(__ia64) && !defined(finite)
+#      define isfinite(x)                                                     \
+        ((sizeof(x) == sizeof(float) ? _Isfinitef(x) : _IsFinite(x)))
+#    else
+#      include <math.h>
+#      define isfinite finite
+#    endif
+#  endif
 #else
-#include <cmath>
-#if !(defined(__QNXNTO__)) // QNX already defines isfinite
-#define isfinite std::isfinite
-#endif
+#  include <cmath>
+#  if !(defined(__QNXNTO__)) // QNX already defines isfinite
+#    define isfinite std::isfinite
+#  endif
 #endif
 
 #if defined(_MSC_VER)
-#if !defined(WINCE) && defined(__STDC_SECURE_LIB__) && _MSC_VER >= 1500 // VC++ 9.0 and above
-#define snprintf sprintf_s
-#elif _MSC_VER >= 1900 // VC++ 14.0 and above
-#define snprintf std::snprintf
-#else
-#define snprintf _snprintf
-#endif
+#  if !defined(WINCE) && defined(__STDC_SECURE_LIB__) &&                      \
+    _MSC_VER >= 1500 // VC++ 9.0 and above
+#    define snprintf sprintf_s
+#  elif _MSC_VER >= 1900 // VC++ 14.0 and above
+#    define snprintf std::snprintf
+#  else
+#    define snprintf _snprintf
+#  endif
 #elif defined(__ANDROID__) || defined(__QNXNTO__)
-#define snprintf snprintf
+#  define snprintf snprintf
 #elif __cplusplus >= 201103L
-#if !defined(__MINGW32__) && !defined(__CYGWIN__)
-#define snprintf std::snprintf
-#endif
+#  if !defined(__MINGW32__) && !defined(__CYGWIN__)
+#    define snprintf std::snprintf
+#  endif
 #endif
 
-#if defined(__BORLANDC__)  
-#include <float.h>
-#define isfinite _finite
-#define snprintf _snprintf
+#if defined(__BORLANDC__)
+#  include <float.h>
+#  define isfinite _finite
+#  define snprintf _snprintf
 #endif
 
 // Solaris
 #if defined(__sun)
-# include <ieeefp.h>
-# if !defined(isfinite)
-#  define isfinite finite
-# endif
+#  include <ieeefp.h>
+#  if !defined(isfinite)
+#    define isfinite finite
+#  endif
 #endif
 
 // AIX
 #if defined(_AIX)
-# if !defined(isfinite)
-#  define isfinite finite
-# endif
+#  if !defined(isfinite)
+#    define isfinite finite
+#  endif
 #endif
 
 // HP-UX
 #if defined(__hpux)
-# if !defined(isfinite)
-#  if defined(__ia64) && !defined(finite) && !defined(__GNUC__)
-#   define isfinite(x) ((sizeof(x) == sizeof(float) ? \
-                        _Isfinitef(x) : _Isfinite(x)))
-#  else
-#   include <math.h>
-#   define isfinite finite
+#  if !defined(isfinite)
+#    if defined(__ia64) && !defined(finite) && !defined(__GNUC__)
+#      define isfinite(x)                                                     \
+        ((sizeof(x) == sizeof(float) ? _Isfinitef(x) : _Isfinite(x)))
+#    else
+#      include <math.h>
+#      define isfinite finite
+#    endif
 #  endif
-# endif
 #endif
 
 // Ancient glibc
 #if defined(__GLIBC__) && __GLIBC__ == 2 && __GLIBC_MINOR__ < 2
-# if !defined(isfinite)
-#  define isfinite __finite
-# endif
+#  if !defined(isfinite)
+#    define isfinite __finite
+#  endif
 #endif
 
 #if defined(_MSC_VER) && _MSC_VER >= 1400 // VC++ 8.0
 // Disable warning about strdup being deprecated.
-#pragma warning(disable : 4996)
+#  pragma warning(disable : 4996)
 #endif
 
 namespace Json {
@@ -113,10 +117,11 @@ namespace Json {
 #if __cplusplus >= 201103L || (defined(_CPPLIB_VER) && _CPPLIB_VER >= 520)
 typedef std::unique_ptr<StreamWriter> StreamWriterPtr;
 #else
-typedef std::auto_ptr<StreamWriter>   StreamWriterPtr;
+typedef std::auto_ptr<StreamWriter> StreamWriterPtr;
 #endif
 
-static bool containsControlCharacter(const char* str) {
+static bool containsControlCharacter(const char* str)
+{
   while (*str) {
     if (isControlCharacter(*(str++)))
       return true;
@@ -124,17 +129,19 @@ static bool containsControlCharacter(const char* str) {
   return false;
 }
 
-static bool containsControlCharacter0(const char* str, unsigned len) {
+static bool containsControlCharacter0(const char* str, unsigned len)
+{
   char const* end = str + len;
   while (end != str) {
-    if (isControlCharacter(*str) || 0==*str)
+    if (isControlCharacter(*str) || 0 == *str)
       return true;
     ++str;
   }
   return false;
 }
 
-JSONCPP_STRING valueToString(LargestInt value) {
+JSONCPP_STRING valueToString(LargestInt value)
+{
   UIntToStringBuffer buffer;
   char* current = buffer + sizeof(buffer);
   if (value == Value::minLargestInt) {
@@ -150,7 +157,8 @@ JSONCPP_STRING valueToString(LargestInt value) {
   return current;
 }
 
-JSONCPP_STRING valueToString(LargestUInt value) {
+JSONCPP_STRING valueToString(LargestUInt value)
+{
   UIntToStringBuffer buffer;
   char* current = buffer + sizeof(buffer);
   uintToString(value, current);
@@ -160,18 +168,22 @@ JSONCPP_STRING valueToString(LargestUInt value) {
 
 #if defined(JSON_HAS_INT64)
 
-JSONCPP_STRING valueToString(Int value) {
+JSONCPP_STRING valueToString(Int value)
+{
   return valueToString(LargestInt(value));
 }
 
-JSONCPP_STRING valueToString(UInt value) {
+JSONCPP_STRING valueToString(UInt value)
+{
   return valueToString(LargestUInt(value));
 }
 
 #endif // # if defined(JSON_HAS_INT64)
 
 namespace {
-JSONCPP_STRING valueToString(double value, bool useSpecialFloats, unsigned int precision) {
+JSONCPP_STRING valueToString(double value, bool useSpecialFloats,
+                             unsigned int precision)
+{
   // Allocate a buffer that is more than large enough to store the 16 digits of
   // precision requested below.
   char buffer[36];
@@ -187,7 +199,8 @@ JSONCPP_STRING valueToString(double value, bool useSpecialFloats, unsigned int p
     len = snprintf(buffer, sizeof(buffer), formatString, value);
     fixNumericLocale(buffer, buffer + len);
 
-    // try to ensure we preserve the fact that this was given to us as a double on input
+    // try to ensure we preserve the fact that this was given to us as a double
+    // on input
     if (!strchr(buffer, '.') && !strchr(buffer, 'e')) {
       strcat(buffer, ".0");
     }
@@ -195,11 +208,14 @@ JSONCPP_STRING valueToString(double value, bool useSpecialFloats, unsigned int p
   } else {
     // IEEE standard states that NaN values will not compare to themselves
     if (value != value) {
-      len = snprintf(buffer, sizeof(buffer), useSpecialFloats ? "NaN" : "null");
+      len =
+        snprintf(buffer, sizeof(buffer), useSpecialFloats ? "NaN" : "null");
     } else if (value < 0) {
-      len = snprintf(buffer, sizeof(buffer), useSpecialFloats ? "-Infinity" : "-1e+9999");
+      len = snprintf(buffer, sizeof(buffer),
+                     useSpecialFloats ? "-Infinity" : "-1e+9999");
     } else {
-      len = snprintf(buffer, sizeof(buffer), useSpecialFloats ? "Infinity" : "1e+9999");
+      len = snprintf(buffer, sizeof(buffer),
+                     useSpecialFloats ? "Infinity" : "1e+9999");
     }
   }
   assert(len >= 0);
@@ -207,11 +223,18 @@ JSONCPP_STRING valueToString(double value, bool useSpecialFloats, unsigned int p
 }
 }
 
-JSONCPP_STRING valueToString(double value) { return valueToString(value, false, 17); }
+JSONCPP_STRING valueToString(double value)
+{
+  return valueToString(value, false, 17);
+}
 
-JSONCPP_STRING valueToString(bool value) { return value ? "true" : "false"; }
+JSONCPP_STRING valueToString(bool value)
+{
+  return value ? "true" : "false";
+}
 
-JSONCPP_STRING valueToQuotedString(const char* value) {
+JSONCPP_STRING valueToQuotedString(const char* value)
+{
   if (value == NULL)
     return "";
   // Not sure how to handle unicode...
@@ -222,51 +245,50 @@ JSONCPP_STRING valueToQuotedString(const char* value) {
   // Appending to JSONCPP_STRING is not efficient, but this should be rare.
   // (Note: forward slashes are *not* rare, but I am not escaping them.)
   JSONCPP_STRING::size_type maxsize =
-      strlen(value) * 2 + 3; // allescaped+quotes+NULL
+    strlen(value) * 2 + 3; // allescaped+quotes+NULL
   JSONCPP_STRING result;
   result.reserve(maxsize); // to avoid lots of mallocs
   result += "\"";
   for (const char* c = value; *c != 0; ++c) {
     switch (*c) {
-    case '\"':
-      result += "\\\"";
-      break;
-    case '\\':
-      result += "\\\\";
-      break;
-    case '\b':
-      result += "\\b";
-      break;
-    case '\f':
-      result += "\\f";
-      break;
-    case '\n':
-      result += "\\n";
-      break;
-    case '\r':
-      result += "\\r";
-      break;
-    case '\t':
-      result += "\\t";
-      break;
-    // case '/':
-    // Even though \/ is considered a legal escape in JSON, a bare
-    // slash is also legal, so I see no reason to escape it.
-    // (I hope I am not misunderstanding something.
-    // blep notes: actually escaping \/ may be useful in javascript to avoid </
-    // sequence.
-    // Should add a flag to allow this compatibility mode and prevent this
-    // sequence from occurring.
-    default:
-      if (isControlCharacter(*c)) {
-        JSONCPP_OSTRINGSTREAM oss;
-        oss << "\\u" << std::hex << std::uppercase << std::setfill('0')
-            << std::setw(4) << static_cast<int>(*c);
-        result += oss.str();
-      } else {
-        result += *c;
-      }
-      break;
+      case '\"':
+        result += "\\\"";
+        break;
+      case '\\':
+        result += "\\\\";
+        break;
+      case '\b':
+        result += "\\b";
+        break;
+      case '\f':
+        result += "\\f";
+        break;
+      case '\n':
+        result += "\\n";
+        break;
+      case '\r':
+        result += "\\r";
+        break;
+      case '\t':
+        result += "\\t";
+        break;
+      // case '/':
+      // Even though \/ is considered a legal escape in JSON, a bare
+      // slash is also legal, so I see no reason to escape it.
+      // (I hope I am not misunderstanding something.
+      // blep notes: actually escaping \/ may be useful in javascript to avoid
+      // </ sequence. Should add a flag to allow this compatibility mode and
+      // prevent this sequence from occurring.
+      default:
+        if (isControlCharacter(*c)) {
+          JSONCPP_OSTRINGSTREAM oss;
+          oss << "\\u" << std::hex << std::uppercase << std::setfill('0')
+              << std::setw(4) << static_cast<int>(*c);
+          result += oss.str();
+        } else {
+          result += *c;
+        }
+        break;
     }
   }
   result += "\"";
@@ -274,7 +296,8 @@ JSONCPP_STRING valueToQuotedString(const char* value) {
 }
 
 // https://github.com/upcaste/upcaste/blob/master/src/upcore/src/cstring/strnpbrk.cpp
-static char const* strnpbrk(char const* s, char const* accept, size_t n) {
+static char const* strnpbrk(char const* s, char const* accept, size_t n)
+{
   assert((s || !n) && accept);
 
   char const* const end = s + n;
@@ -288,7 +311,8 @@ static char const* strnpbrk(char const* s, char const* accept, size_t n) {
   }
   return NULL;
 }
-static JSONCPP_STRING valueToQuotedStringN(const char* value, unsigned length) {
+static JSONCPP_STRING valueToQuotedStringN(const char* value, unsigned length)
+{
   if (value == NULL)
     return "";
   // Not sure how to handle unicode...
@@ -298,53 +322,51 @@ static JSONCPP_STRING valueToQuotedStringN(const char* value, unsigned length) {
   // We have to walk value and escape any special characters.
   // Appending to JSONCPP_STRING is not efficient, but this should be rare.
   // (Note: forward slashes are *not* rare, but I am not escaping them.)
-  JSONCPP_STRING::size_type maxsize =
-      length * 2 + 3; // allescaped+quotes+NULL
+  JSONCPP_STRING::size_type maxsize = length * 2 + 3; // allescaped+quotes+NULL
   JSONCPP_STRING result;
   result.reserve(maxsize); // to avoid lots of mallocs
   result += "\"";
   char const* end = value + length;
   for (const char* c = value; c != end; ++c) {
     switch (*c) {
-    case '\"':
-      result += "\\\"";
-      break;
-    case '\\':
-      result += "\\\\";
-      break;
-    case '\b':
-      result += "\\b";
-      break;
-    case '\f':
-      result += "\\f";
-      break;
-    case '\n':
-      result += "\\n";
-      break;
-    case '\r':
-      result += "\\r";
-      break;
-    case '\t':
-      result += "\\t";
-      break;
-    // case '/':
-    // Even though \/ is considered a legal escape in JSON, a bare
-    // slash is also legal, so I see no reason to escape it.
-    // (I hope I am not misunderstanding something.)
-    // blep notes: actually escaping \/ may be useful in javascript to avoid </
-    // sequence.
-    // Should add a flag to allow this compatibility mode and prevent this
-    // sequence from occurring.
-    default:
-      if ((isControlCharacter(*c)) || (*c == 0)) {
-        JSONCPP_OSTRINGSTREAM oss;
-        oss << "\\u" << std::hex << std::uppercase << std::setfill('0')
-            << std::setw(4) << static_cast<int>(*c);
-        result += oss.str();
-      } else {
-        result += *c;
-      }
-      break;
+      case '\"':
+        result += "\\\"";
+        break;
+      case '\\':
+        result += "\\\\";
+        break;
+      case '\b':
+        result += "\\b";
+        break;
+      case '\f':
+        result += "\\f";
+        break;
+      case '\n':
+        result += "\\n";
+        break;
+      case '\r':
+        result += "\\r";
+        break;
+      case '\t':
+        result += "\\t";
+        break;
+      // case '/':
+      // Even though \/ is considered a legal escape in JSON, a bare
+      // slash is also legal, so I see no reason to escape it.
+      // (I hope I am not misunderstanding something.)
+      // blep notes: actually escaping \/ may be useful in javascript to avoid
+      // </ sequence. Should add a flag to allow this compatibility mode and
+      // prevent this sequence from occurring.
+      default:
+        if ((isControlCharacter(*c)) || (*c == 0)) {
+          JSONCPP_OSTRINGSTREAM oss;
+          oss << "\\u" << std::hex << std::uppercase << std::setfill('0')
+              << std::setw(4) << static_cast<int>(*c);
+          result += oss.str();
+        } else {
+          result += *c;
+        }
+        break;
     }
   }
   result += "\"";
@@ -353,80 +375,98 @@ static JSONCPP_STRING valueToQuotedStringN(const char* value, unsigned length) {
 
 // Class Writer
 // //////////////////////////////////////////////////////////////////
-Writer::~Writer() {}
+Writer::~Writer()
+{
+}
 
 // Class FastWriter
 // //////////////////////////////////////////////////////////////////
 
 FastWriter::FastWriter()
-    : yamlCompatiblityEnabled_(false), dropNullPlaceholders_(false),
-      omitEndingLineFeed_(false) {}
+  : yamlCompatiblityEnabled_(false)
+  , dropNullPlaceholders_(false)
+  , omitEndingLineFeed_(false)
+{
+}
 
-void FastWriter::enableYAMLCompatibility() { yamlCompatiblityEnabled_ = true; }
+void FastWriter::enableYAMLCompatibility()
+{
+  this->yamlCompatiblityEnabled_ = true;
+}
 
-void FastWriter::dropNullPlaceholders() { dropNullPlaceholders_ = true; }
+void FastWriter::dropNullPlaceholders()
+{
+  this->dropNullPlaceholders_ = true;
+}
 
-void FastWriter::omitEndingLineFeed() { omitEndingLineFeed_ = true; }
+void FastWriter::omitEndingLineFeed()
+{
+  this->omitEndingLineFeed_ = true;
+}
 
-JSONCPP_STRING FastWriter::write(const Value& root) {
-  document_.clear();
-  writeValue(root);
-  if (!omitEndingLineFeed_)
-    document_ += "\n";
-  return document_;
+JSONCPP_STRING FastWriter::write(const Value& root)
+{
+  this->document_.clear();
+  this->writeValue(root);
+  if (!this->omitEndingLineFeed_)
+    this->document_ += "\n";
+  return this->document_;
 }
 
-void FastWriter::writeValue(const Value& value) {
+void FastWriter::writeValue(const Value& value)
+{
   switch (value.type()) {
-  case nullValue:
-    if (!dropNullPlaceholders_)
-      document_ += "null";
-    break;
-  case intValue:
-    document_ += valueToString(value.asLargestInt());
-    break;
-  case uintValue:
-    document_ += valueToString(value.asLargestUInt());
-    break;
-  case realValue:
-    document_ += valueToString(value.asDouble());
-    break;
-  case stringValue:
-  {
-    // Is NULL possible for value.string_? No.
-    char const* str;
-    char const* end;
-    bool ok = value.getString(&str, &end);
-    if (ok) document_ += valueToQuotedStringN(str, static_cast<unsigned>(end-str));
-    break;
-  }
-  case booleanValue:
-    document_ += valueToString(value.asBool());
-    break;
-  case arrayValue: {
-    document_ += '[';
-    ArrayIndex size = value.size();
-    for (ArrayIndex index = 0; index < size; ++index) {
-      if (index > 0)
-        document_ += ',';
-      writeValue(value[index]);
-    }
-    document_ += ']';
-  } break;
-  case objectValue: {
-    Value::Members members(value.getMemberNames());
-    document_ += '{';
-    for (Value::Members::iterator it = members.begin(); it != members.end();
-         ++it) {
-      const JSONCPP_STRING& name = *it;
-      if (it != members.begin())
-        document_ += ',';
-      document_ += valueToQuotedStringN(name.data(), static_cast<unsigned>(name.length()));
-      document_ += yamlCompatiblityEnabled_ ? ": " : ":";
-      writeValue(value[name]);
+    case nullValue:
+      if (!this->dropNullPlaceholders_)
+        this->document_ += "null";
+      break;
+    case intValue:
+      this->document_ += valueToString(value.asLargestInt());
+      break;
+    case uintValue:
+      this->document_ += valueToString(value.asLargestUInt());
+      break;
+    case realValue:
+      this->document_ += valueToString(value.asDouble());
+      break;
+    case stringValue: {
+      // Is NULL possible for value.string_? No.
+      char const* str;
+      char const* end;
+      bool ok = value.getString(&str, &end);
+      if (ok)
+        this->document_ +=
+          valueToQuotedStringN(str, static_cast<unsigned>(end - str));
+      break;
     }
-    document_ += '}';
-  } break;
+    case booleanValue:
+      this->document_ += valueToString(value.asBool());
+      break;
+    case arrayValue: {
+      this->document_ += '[';
+      ArrayIndex size = value.size();
+      for (ArrayIndex index = 0; index < size; ++index) {
+        if (index > 0)
+          this->document_ += ',';
+        this->writeValue(value[index]);
+      }
+      this->document_ += ']';
+    } break;
+    case objectValue: {
+      Value::Members members(value.getMemberNames());
+      this->document_ += '{';
+      for (Value::Members::iterator it = members.begin(); it != members.end();
+           ++it) {
+        const JSONCPP_STRING& name = *it;
+        if (it != members.begin())
+          this->document_ += ',';
+        this->document_ += valueToQuotedStringN(
+          name.data(), static_cast<unsigned>(name.length()));
+        this->document_ += this->yamlCompatiblityEnabled_ ? ": " : ":";
+        this->writeValue(value[name]);
+      }
+      this->document_ += '}';
+    } break;
   }
 }
 
@@ -434,454 +474,498 @@ void FastWriter::writeValue(const Value& value) {
 // //////////////////////////////////////////////////////////////////
 
 StyledWriter::StyledWriter()
-    : rightMargin_(74), indentSize_(3), addChildValues_() {}
+  : rightMargin_(74)
+  , indentSize_(3)
+  , addChildValues_()
+{
+}
 
-JSONCPP_STRING StyledWriter::write(const Value& root) {
-  document_.clear();
-  addChildValues_ = false;
-  indentString_.clear();
-  writeCommentBeforeValue(root);
-  writeValue(root);
-  writeCommentAfterValueOnSameLine(root);
-  document_ += "\n";
-  return document_;
+JSONCPP_STRING StyledWriter::write(const Value& root)
+{
+  this->document_.clear();
+  this->addChildValues_ = false;
+  this->indentString_.clear();
+  this->writeCommentBeforeValue(root);
+  this->writeValue(root);
+  this->writeCommentAfterValueOnSameLine(root);
+  this->document_ += "\n";
+  return this->document_;
 }
 
-void StyledWriter::writeValue(const Value& value) {
+void StyledWriter::writeValue(const Value& value)
+{
   switch (value.type()) {
-  case nullValue:
-    pushValue("null");
-    break;
-  case intValue:
-    pushValue(valueToString(value.asLargestInt()));
-    break;
-  case uintValue:
-    pushValue(valueToString(value.asLargestUInt()));
-    break;
-  case realValue:
-    pushValue(valueToString(value.asDouble()));
-    break;
-  case stringValue:
-  {
-    // Is NULL possible for value.string_? No.
-    char const* str;
-    char const* end;
-    bool ok = value.getString(&str, &end);
-    if (ok) pushValue(valueToQuotedStringN(str, static_cast<unsigned>(end-str)));
-    else pushValue("");
-    break;
-  }
-  case booleanValue:
-    pushValue(valueToString(value.asBool()));
-    break;
-  case arrayValue:
-    writeArrayValue(value);
-    break;
-  case objectValue: {
-    Value::Members members(value.getMemberNames());
-    if (members.empty())
-      pushValue("{}");
-    else {
-      writeWithIndent("{");
-      indent();
-      Value::Members::iterator it = members.begin();
-      for (;;) {
-        const JSONCPP_STRING& name = *it;
-        const Value& childValue = value[name];
-        writeCommentBeforeValue(childValue);
-        writeWithIndent(valueToQuotedString(name.c_str()));
-        document_ += " : ";
-        writeValue(childValue);
-        if (++it == members.end()) {
-          writeCommentAfterValueOnSameLine(childValue);
-          break;
+    case nullValue:
+      this->pushValue("null");
+      break;
+    case intValue:
+      this->pushValue(valueToString(value.asLargestInt()));
+      break;
+    case uintValue:
+      this->pushValue(valueToString(value.asLargestUInt()));
+      break;
+    case realValue:
+      this->pushValue(valueToString(value.asDouble()));
+      break;
+    case stringValue: {
+      // Is NULL possible for value.string_? No.
+      char const* str;
+      char const* end;
+      bool ok = value.getString(&str, &end);
+      if (ok)
+        this->pushValue(
+          valueToQuotedStringN(str, static_cast<unsigned>(end - str)));
+      else
+        this->pushValue("");
+      break;
+    }
+    case booleanValue:
+      this->pushValue(valueToString(value.asBool()));
+      break;
+    case arrayValue:
+      this->writeArrayValue(value);
+      break;
+    case objectValue: {
+      Value::Members members(value.getMemberNames());
+      if (members.empty())
+        this->pushValue("{}");
+      else {
+        this->writeWithIndent("{");
+        this->indent();
+        Value::Members::iterator it = members.begin();
+        for (;;) {
+          const JSONCPP_STRING& name = *it;
+          const Value& childValue = value[name];
+          this->writeCommentBeforeValue(childValue);
+          this->writeWithIndent(valueToQuotedString(name.c_str()));
+          this->document_ += " : ";
+          this->writeValue(childValue);
+          if (++it == members.end()) {
+            this->writeCommentAfterValueOnSameLine(childValue);
+            break;
+          }
+          this->document_ += ',';
+          this->writeCommentAfterValueOnSameLine(childValue);
         }
-        document_ += ',';
-        writeCommentAfterValueOnSameLine(childValue);
+        this->unindent();
+        this->writeWithIndent("}");
       }
-      unindent();
-      writeWithIndent("}");
-    }
-  } break;
+    } break;
   }
 }
 
-void StyledWriter::writeArrayValue(const Value& value) {
+void StyledWriter::writeArrayValue(const Value& value)
+{
   unsigned size = value.size();
   if (size == 0)
-    pushValue("[]");
+    this->pushValue("[]");
   else {
-    bool isArrayMultiLine = isMultineArray(value);
+    bool isArrayMultiLine = this->isMultineArray(value);
     if (isArrayMultiLine) {
-      writeWithIndent("[");
-      indent();
-      bool hasChildValue = !childValues_.empty();
+      this->writeWithIndent("[");
+      this->indent();
+      bool hasChildValue = !this->childValues_.empty();
       unsigned index = 0;
       for (;;) {
         const Value& childValue = value[index];
-        writeCommentBeforeValue(childValue);
+        this->writeCommentBeforeValue(childValue);
         if (hasChildValue)
-          writeWithIndent(childValues_[index]);
+          this->writeWithIndent(this->childValues_[index]);
         else {
-          writeIndent();
-          writeValue(childValue);
+          this->writeIndent();
+          this->writeValue(childValue);
         }
         if (++index == size) {
-          writeCommentAfterValueOnSameLine(childValue);
+          this->writeCommentAfterValueOnSameLine(childValue);
           break;
         }
-        document_ += ',';
-        writeCommentAfterValueOnSameLine(childValue);
+        this->document_ += ',';
+        this->writeCommentAfterValueOnSameLine(childValue);
       }
-      unindent();
-      writeWithIndent("]");
+      this->unindent();
+      this->writeWithIndent("]");
     } else // output on a single line
     {
-      assert(childValues_.size() == size);
-      document_ += "[ ";
+      assert(this->childValues_.size() == size);
+      this->document_ += "[ ";
       for (unsigned index = 0; index < size; ++index) {
         if (index > 0)
-          document_ += ", ";
-        document_ += childValues_[index];
+          this->document_ += ", ";
+        this->document_ += this->childValues_[index];
       }
-      document_ += " ]";
+      this->document_ += " ]";
     }
   }
 }
 
-bool StyledWriter::isMultineArray(const Value& value) {
+bool StyledWriter::isMultineArray(const Value& value)
+{
   ArrayIndex const size = value.size();
-  bool isMultiLine = size * 3 >= rightMargin_;
-  childValues_.clear();
+  bool isMultiLine = size * 3 >= this->rightMargin_;
+  this->childValues_.clear();
   for (ArrayIndex index = 0; index < size && !isMultiLine; ++index) {
     const Value& childValue = value[index];
     isMultiLine = ((childValue.isArray() || childValue.isObject()) &&
-                        childValue.size() > 0);
+                   childValue.size() > 0);
   }
   if (!isMultiLine) // check if line length > max line length
   {
-    childValues_.reserve(size);
-    addChildValues_ = true;
+    this->childValues_.reserve(size);
+    this->addChildValues_ = true;
     ArrayIndex lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]'
     for (ArrayIndex index = 0; index < size; ++index) {
-      if (hasCommentForValue(value[index])) {
+      if (this->hasCommentForValue(value[index])) {
         isMultiLine = true;
       }
-      writeValue(value[index]);
-      lineLength += static_cast<ArrayIndex>(childValues_[index].length());
+      this->writeValue(value[index]);
+      lineLength +=
+        static_cast<ArrayIndex>(this->childValues_[index].length());
     }
-    addChildValues_ = false;
-    isMultiLine = isMultiLine || lineLength >= rightMargin_;
+    this->addChildValues_ = false;
+    isMultiLine = isMultiLine || lineLength >= this->rightMargin_;
   }
   return isMultiLine;
 }
 
-void StyledWriter::pushValue(const JSONCPP_STRING& value) {
-  if (addChildValues_)
-    childValues_.push_back(value);
+void StyledWriter::pushValue(const JSONCPP_STRING& value)
+{
+  if (this->addChildValues_)
+    this->childValues_.push_back(value);
   else
-    document_ += value;
+    this->document_ += value;
 }
 
-void StyledWriter::writeIndent() {
-  if (!document_.empty()) {
-    char last = document_[document_.length() - 1];
+void StyledWriter::writeIndent()
+{
+  if (!this->document_.empty()) {
+    char last = this->document_[this->document_.length() - 1];
     if (last == ' ') // already indented
       return;
     if (last != '\n') // Comments may add new-line
-      document_ += '\n';
+      this->document_ += '\n';
   }
-  document_ += indentString_;
+  this->document_ += this->indentString_;
 }
 
-void StyledWriter::writeWithIndent(const JSONCPP_STRING& value) {
-  writeIndent();
-  document_ += value;
+void StyledWriter::writeWithIndent(const JSONCPP_STRING& value)
+{
+  this->writeIndent();
+  this->document_ += value;
 }
 
-void StyledWriter::indent() { indentString_ += JSONCPP_STRING(indentSize_, ' '); }
+void StyledWriter::indent()
+{
+  this->indentString_ += JSONCPP_STRING(this->indentSize_, ' ');
+}
 
-void StyledWriter::unindent() {
-  assert(indentString_.size() >= indentSize_);
-  indentString_.resize(indentString_.size() - indentSize_);
+void StyledWriter::unindent()
+{
+  assert(this->indentString_.size() >= this->indentSize_);
+  this->indentString_.resize(this->indentString_.size() - this->indentSize_);
 }
 
-void StyledWriter::writeCommentBeforeValue(const Value& root) {
+void StyledWriter::writeCommentBeforeValue(const Value& root)
+{
   if (!root.hasComment(commentBefore))
     return;
 
-  document_ += "\n";
-  writeIndent();
+  this->document_ += "\n";
+  this->writeIndent();
   const JSONCPP_STRING& comment = root.getComment(commentBefore);
   JSONCPP_STRING::const_iterator iter = comment.begin();
   while (iter != comment.end()) {
-    document_ += *iter;
-    if (*iter == '\n' &&
-       (iter != comment.end() && *(iter + 1) == '/'))
-      writeIndent();
+    this->document_ += *iter;
+    if (*iter == '\n' && (iter != comment.end() && *(iter + 1) == '/'))
+      this->writeIndent();
     ++iter;
   }
 
   // Comments are stripped of trailing newlines, so add one here
-  document_ += "\n";
+  this->document_ += "\n";
 }
 
-void StyledWriter::writeCommentAfterValueOnSameLine(const Value& root) {
+void StyledWriter::writeCommentAfterValueOnSameLine(const Value& root)
+{
   if (root.hasComment(commentAfterOnSameLine))
-    document_ += " " + root.getComment(commentAfterOnSameLine);
+    this->document_ += " " + root.getComment(commentAfterOnSameLine);
 
   if (root.hasComment(commentAfter)) {
-    document_ += "\n";
-    document_ += root.getComment(commentAfter);
-    document_ += "\n";
+    this->document_ += "\n";
+    this->document_ += root.getComment(commentAfter);
+    this->document_ += "\n";
   }
 }
 
-bool StyledWriter::hasCommentForValue(const Value& value) {
+bool StyledWriter::hasCommentForValue(const Value& value)
+{
   return value.hasComment(commentBefore) ||
-         value.hasComment(commentAfterOnSameLine) ||
-         value.hasComment(commentAfter);
+    value.hasComment(commentAfterOnSameLine) || value.hasComment(commentAfter);
 }
 
 // Class StyledStreamWriter
 // //////////////////////////////////////////////////////////////////
 
 StyledStreamWriter::StyledStreamWriter(JSONCPP_STRING indentation)
-    : document_(NULL), rightMargin_(74), indentation_(indentation),
-      addChildValues_() {}
-
-void StyledStreamWriter::write(JSONCPP_OSTREAM& out, const Value& root) {
-  document_ = &out;
-  addChildValues_ = false;
-  indentString_.clear();
-  indented_ = true;
-  writeCommentBeforeValue(root);
-  if (!indented_) writeIndent();
-  indented_ = true;
-  writeValue(root);
-  writeCommentAfterValueOnSameLine(root);
-  *document_ << "\n";
-  document_ = NULL; // Forget the stream, for safety.
-}
-
-void StyledStreamWriter::writeValue(const Value& value) {
+  : document_(NULL)
+  , rightMargin_(74)
+  , indentation_(indentation)
+  , addChildValues_()
+{
+}
+
+void StyledStreamWriter::write(JSONCPP_OSTREAM& out, const Value& root)
+{
+  this->document_ = &out;
+  this->addChildValues_ = false;
+  this->indentString_.clear();
+  this->indented_ = true;
+  this->writeCommentBeforeValue(root);
+  if (!this->indented_)
+    this->writeIndent();
+  this->indented_ = true;
+  this->writeValue(root);
+  this->writeCommentAfterValueOnSameLine(root);
+  *this->document_ << "\n";
+  this->document_ = NULL; // Forget the stream, for safety.
+}
+
+void StyledStreamWriter::writeValue(const Value& value)
+{
   switch (value.type()) {
-  case nullValue:
-    pushValue("null");
-    break;
-  case intValue:
-    pushValue(valueToString(value.asLargestInt()));
-    break;
-  case uintValue:
-    pushValue(valueToString(value.asLargestUInt()));
-    break;
-  case realValue:
-    pushValue(valueToString(value.asDouble()));
-    break;
-  case stringValue:
-  {
-    // Is NULL possible for value.string_? No.
-    char const* str;
-    char const* end;
-    bool ok = value.getString(&str, &end);
-    if (ok) pushValue(valueToQuotedStringN(str, static_cast<unsigned>(end-str)));
-    else pushValue("");
-    break;
-  }
-  case booleanValue:
-    pushValue(valueToString(value.asBool()));
-    break;
-  case arrayValue:
-    writeArrayValue(value);
-    break;
-  case objectValue: {
-    Value::Members members(value.getMemberNames());
-    if (members.empty())
-      pushValue("{}");
-    else {
-      writeWithIndent("{");
-      indent();
-      Value::Members::iterator it = members.begin();
-      for (;;) {
-        const JSONCPP_STRING& name = *it;
-        const Value& childValue = value[name];
-        writeCommentBeforeValue(childValue);
-        writeWithIndent(valueToQuotedString(name.c_str()));
-        *document_ << " : ";
-        writeValue(childValue);
-        if (++it == members.end()) {
-          writeCommentAfterValueOnSameLine(childValue);
-          break;
+    case nullValue:
+      this->pushValue("null");
+      break;
+    case intValue:
+      this->pushValue(valueToString(value.asLargestInt()));
+      break;
+    case uintValue:
+      this->pushValue(valueToString(value.asLargestUInt()));
+      break;
+    case realValue:
+      this->pushValue(valueToString(value.asDouble()));
+      break;
+    case stringValue: {
+      // Is NULL possible for value.string_? No.
+      char const* str;
+      char const* end;
+      bool ok = value.getString(&str, &end);
+      if (ok)
+        this->pushValue(
+          valueToQuotedStringN(str, static_cast<unsigned>(end - str)));
+      else
+        this->pushValue("");
+      break;
+    }
+    case booleanValue:
+      this->pushValue(valueToString(value.asBool()));
+      break;
+    case arrayValue:
+      this->writeArrayValue(value);
+      break;
+    case objectValue: {
+      Value::Members members(value.getMemberNames());
+      if (members.empty())
+        this->pushValue("{}");
+      else {
+        this->writeWithIndent("{");
+        this->indent();
+        Value::Members::iterator it = members.begin();
+        for (;;) {
+          const JSONCPP_STRING& name = *it;
+          const Value& childValue = value[name];
+          this->writeCommentBeforeValue(childValue);
+          this->writeWithIndent(valueToQuotedString(name.c_str()));
+          *this->document_ << " : ";
+          this->writeValue(childValue);
+          if (++it == members.end()) {
+            this->writeCommentAfterValueOnSameLine(childValue);
+            break;
+          }
+          *this->document_ << ",";
+          this->writeCommentAfterValueOnSameLine(childValue);
         }
-        *document_ << ",";
-        writeCommentAfterValueOnSameLine(childValue);
+        this->unindent();
+        this->writeWithIndent("}");
       }
-      unindent();
-      writeWithIndent("}");
-    }
-  } break;
+    } break;
   }
 }
 
-void StyledStreamWriter::writeArrayValue(const Value& value) {
+void StyledStreamWriter::writeArrayValue(const Value& value)
+{
   unsigned size = value.size();
   if (size == 0)
-    pushValue("[]");
+    this->pushValue("[]");
   else {
-    bool isArrayMultiLine = isMultineArray(value);
+    bool isArrayMultiLine = this->isMultineArray(value);
     if (isArrayMultiLine) {
-      writeWithIndent("[");
-      indent();
-      bool hasChildValue = !childValues_.empty();
+      this->writeWithIndent("[");
+      this->indent();
+      bool hasChildValue = !this->childValues_.empty();
       unsigned index = 0;
       for (;;) {
         const Value& childValue = value[index];
-        writeCommentBeforeValue(childValue);
+        this->writeCommentBeforeValue(childValue);
         if (hasChildValue)
-          writeWithIndent(childValues_[index]);
+          this->writeWithIndent(this->childValues_[index]);
         else {
-          if (!indented_) writeIndent();
-          indented_ = true;
-          writeValue(childValue);
-          indented_ = false;
+          if (!this->indented_)
+            this->writeIndent();
+          this->indented_ = true;
+          this->writeValue(childValue);
+          this->indented_ = false;
         }
         if (++index == size) {
-          writeCommentAfterValueOnSameLine(childValue);
+          this->writeCommentAfterValueOnSameLine(childValue);
           break;
         }
-        *document_ << ",";
-        writeCommentAfterValueOnSameLine(childValue);
+        *this->document_ << ",";
+        this->writeCommentAfterValueOnSameLine(childValue);
       }
-      unindent();
-      writeWithIndent("]");
+      this->unindent();
+      this->writeWithIndent("]");
     } else // output on a single line
     {
-      assert(childValues_.size() == size);
-      *document_ << "[ ";
+      assert(this->childValues_.size() == size);
+      *this->document_ << "[ ";
       for (unsigned index = 0; index < size; ++index) {
         if (index > 0)
-          *document_ << ", ";
-        *document_ << childValues_[index];
+          *this->document_ << ", ";
+        *this->document_ << this->childValues_[index];
       }
-      *document_ << " ]";
+      *this->document_ << " ]";
     }
   }
 }
 
-bool StyledStreamWriter::isMultineArray(const Value& value) {
+bool StyledStreamWriter::isMultineArray(const Value& value)
+{
   ArrayIndex const size = value.size();
-  bool isMultiLine = size * 3 >= rightMargin_;
-  childValues_.clear();
+  bool isMultiLine = size * 3 >= this->rightMargin_;
+  this->childValues_.clear();
   for (ArrayIndex index = 0; index < size && !isMultiLine; ++index) {
     const Value& childValue = value[index];
     isMultiLine = ((childValue.isArray() || childValue.isObject()) &&
-                        childValue.size() > 0);
+                   childValue.size() > 0);
   }
   if (!isMultiLine) // check if line length > max line length
   {
-    childValues_.reserve(size);
-    addChildValues_ = true;
+    this->childValues_.reserve(size);
+    this->addChildValues_ = true;
     ArrayIndex lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]'
     for (ArrayIndex index = 0; index < size; ++index) {
-      if (hasCommentForValue(value[index])) {
+      if (this->hasCommentForValue(value[index])) {
         isMultiLine = true;
       }
-      writeValue(value[index]);
-      lineLength += static_cast<ArrayIndex>(childValues_[index].length());
+      this->writeValue(value[index]);
+      lineLength +=
+        static_cast<ArrayIndex>(this->childValues_[index].length());
     }
-    addChildValues_ = false;
-    isMultiLine = isMultiLine || lineLength >= rightMargin_;
+    this->addChildValues_ = false;
+    isMultiLine = isMultiLine || lineLength >= this->rightMargin_;
   }
   return isMultiLine;
 }
 
-void StyledStreamWriter::pushValue(const JSONCPP_STRING& value) {
-  if (addChildValues_)
-    childValues_.push_back(value);
+void StyledStreamWriter::pushValue(const JSONCPP_STRING& value)
+{
+  if (this->addChildValues_)
+    this->childValues_.push_back(value);
   else
-    *document_ << value;
+    *this->document_ << value;
 }
 
-void StyledStreamWriter::writeIndent() {
+void StyledStreamWriter::writeIndent()
+{
   // blep intended this to look at the so-far-written string
   // to determine whether we are already indented, but
   // with a stream we cannot do that. So we rely on some saved state.
   // The caller checks indented_.
-  *document_ << '\n' << indentString_;
+  *this->document_ << '\n' << this->indentString_;
 }
 
-void StyledStreamWriter::writeWithIndent(const JSONCPP_STRING& value) {
-  if (!indented_) writeIndent();
-  *document_ << value;
-  indented_ = false;
+void StyledStreamWriter::writeWithIndent(const JSONCPP_STRING& value)
+{
+  if (!this->indented_)
+    this->writeIndent();
+  *this->document_ << value;
+  this->indented_ = false;
 }
 
-void StyledStreamWriter::indent() { indentString_ += indentation_; }
+void StyledStreamWriter::indent()
+{
+  this->indentString_ += this->indentation_;
+}
 
-void StyledStreamWriter::unindent() {
-  assert(indentString_.size() >= indentation_.size());
-  indentString_.resize(indentString_.size() - indentation_.size());
+void StyledStreamWriter::unindent()
+{
+  assert(this->indentString_.size() >= this->indentation_.size());
+  this->indentString_.resize(this->indentString_.size() -
+                             this->indentation_.size());
 }
 
-void StyledStreamWriter::writeCommentBeforeValue(const Value& root) {
+void StyledStreamWriter::writeCommentBeforeValue(const Value& root)
+{
   if (!root.hasComment(commentBefore))
     return;
 
-  if (!indented_) writeIndent();
+  if (!this->indented_)
+    this->writeIndent();
   const JSONCPP_STRING& comment = root.getComment(commentBefore);
   JSONCPP_STRING::const_iterator iter = comment.begin();
   while (iter != comment.end()) {
-    *document_ << *iter;
-    if (*iter == '\n' &&
-       (iter != comment.end() && *(iter + 1) == '/'))
+    *this->document_ << *iter;
+    if (*iter == '\n' && (iter != comment.end() && *(iter + 1) == '/'))
       // writeIndent();  // would include newline
-      *document_ << indentString_;
+      *this->document_ << this->indentString_;
     ++iter;
   }
-  indented_ = false;
+  this->indented_ = false;
 }
 
-void StyledStreamWriter::writeCommentAfterValueOnSameLine(const Value& root) {
+void StyledStreamWriter::writeCommentAfterValueOnSameLine(const Value& root)
+{
   if (root.hasComment(commentAfterOnSameLine))
-    *document_ << ' ' << root.getComment(commentAfterOnSameLine);
+    *this->document_ << ' ' << root.getComment(commentAfterOnSameLine);
 
   if (root.hasComment(commentAfter)) {
-    writeIndent();
-    *document_ << root.getComment(commentAfter);
+    this->writeIndent();
+    *this->document_ << root.getComment(commentAfter);
   }
-  indented_ = false;
+  this->indented_ = false;
 }
 
-bool StyledStreamWriter::hasCommentForValue(const Value& value) {
+bool StyledStreamWriter::hasCommentForValue(const Value& value)
+{
   return value.hasComment(commentBefore) ||
-         value.hasComment(commentAfterOnSameLine) ||
-         value.hasComment(commentAfter);
+    value.hasComment(commentAfterOnSameLine) || value.hasComment(commentAfter);
 }
 
 //////////////////////////
 // BuiltStyledStreamWriter
 
 /// Scoped enums are not available until C++11.
-struct CommentStyle {
+struct CommentStyle
+{
   /// Decide whether to write comments.
-  enum Enum {
-    None,  ///< Drop all comments.
-    Most,  ///< Recover odd behavior of previous versions (not implemented yet).
-    All  ///< Keep all comments.
+  enum Enum
+  {
+    None, ///< Drop all comments.
+    Most, ///< Recover odd behavior of previous versions (not implemented yet).
+    All   ///< Keep all comments.
   };
 };
 
 struct BuiltStyledStreamWriter : public StreamWriter
 {
-  BuiltStyledStreamWriter(
-      JSONCPP_STRING const& indentation,
-      CommentStyle::Enum cs,
-      JSONCPP_STRING const& colonSymbol,
-      JSONCPP_STRING const& nullSymbol,
-      JSONCPP_STRING const& endingLineFeedSymbol,
-      bool useSpecialFloats,
-      unsigned int precision);
+  BuiltStyledStreamWriter(JSONCPP_STRING const& indentation,
+                          CommentStyle::Enum cs,
+                          JSONCPP_STRING const& colonSymbol,
+                          JSONCPP_STRING const& nullSymbol,
+                          JSONCPP_STRING const& endingLineFeedSymbol,
+                          bool useSpecialFloats, unsigned int precision);
   int write(Value const& root, JSONCPP_OSTREAM* sout) JSONCPP_OVERRIDE;
+
 private:
   void writeValue(Value const& value);
   void writeArrayValue(Value const& value);
@@ -911,13 +995,10 @@ private:
   unsigned int precision_;
 };
 BuiltStyledStreamWriter::BuiltStyledStreamWriter(
-      JSONCPP_STRING const& indentation,
-      CommentStyle::Enum cs,
-      JSONCPP_STRING const& colonSymbol,
-      JSONCPP_STRING const& nullSymbol,
-      JSONCPP_STRING const& endingLineFeedSymbol,
-      bool useSpecialFloats,
-      unsigned int precision)
+  JSONCPP_STRING const& indentation, CommentStyle::Enum cs,
+  JSONCPP_STRING const& colonSymbol, JSONCPP_STRING const& nullSymbol,
+  JSONCPP_STRING const& endingLineFeedSymbol, bool useSpecialFloats,
+  unsigned int precision)
   : rightMargin_(74)
   , indentation_(indentation)
   , cs_(cs)
@@ -932,247 +1013,276 @@ BuiltStyledStreamWriter::BuiltStyledStreamWriter(
 }
 int BuiltStyledStreamWriter::write(Value const& root, JSONCPP_OSTREAM* sout)
 {
-  sout_ = sout;
-  addChildValues_ = false;
-  indented_ = true;
-  indentString_.clear();
-  writeCommentBeforeValue(root);
-  if (!indented_) writeIndent();
-  indented_ = true;
-  writeValue(root);
-  writeCommentAfterValueOnSameLine(root);
-  *sout_ << endingLineFeedSymbol_;
-  sout_ = NULL;
+  this->sout_ = sout;
+  this->addChildValues_ = false;
+  this->indented_ = true;
+  this->indentString_.clear();
+  this->writeCommentBeforeValue(root);
+  if (!this->indented_)
+    this->writeIndent();
+  this->indented_ = true;
+  this->writeValue(root);
+  this->writeCommentAfterValueOnSameLine(root);
+  *this->sout_ << this->endingLineFeedSymbol_;
+  this->sout_ = NULL;
   return 0;
 }
-void BuiltStyledStreamWriter::writeValue(Value const& value) {
+void BuiltStyledStreamWriter::writeValue(Value const& value)
+{
   switch (value.type()) {
-  case nullValue:
-    pushValue(nullSymbol_);
-    break;
-  case intValue:
-    pushValue(valueToString(value.asLargestInt()));
-    break;
-  case uintValue:
-    pushValue(valueToString(value.asLargestUInt()));
-    break;
-  case realValue:
-    pushValue(valueToString(value.asDouble(), useSpecialFloats_, precision_));
-    break;
-  case stringValue:
-  {
-    // Is NULL is possible for value.string_? No.
-    char const* str;
-    char const* end;
-    bool ok = value.getString(&str, &end);
-    if (ok) pushValue(valueToQuotedStringN(str, static_cast<unsigned>(end-str)));
-    else pushValue("");
-    break;
-  }
-  case booleanValue:
-    pushValue(valueToString(value.asBool()));
-    break;
-  case arrayValue:
-    writeArrayValue(value);
-    break;
-  case objectValue: {
-    Value::Members members(value.getMemberNames());
-    if (members.empty())
-      pushValue("{}");
-    else {
-      writeWithIndent("{");
-      indent();
-      Value::Members::iterator it = members.begin();
-      for (;;) {
-        JSONCPP_STRING const& name = *it;
-        Value const& childValue = value[name];
-        writeCommentBeforeValue(childValue);
-        writeWithIndent(valueToQuotedStringN(name.data(), static_cast<unsigned>(name.length())));
-        *sout_ << colonSymbol_;
-        writeValue(childValue);
-        if (++it == members.end()) {
-          writeCommentAfterValueOnSameLine(childValue);
-          break;
+    case nullValue:
+      this->pushValue(this->nullSymbol_);
+      break;
+    case intValue:
+      this->pushValue(valueToString(value.asLargestInt()));
+      break;
+    case uintValue:
+      this->pushValue(valueToString(value.asLargestUInt()));
+      break;
+    case realValue:
+      this->pushValue(valueToString(value.asDouble(), this->useSpecialFloats_,
+                                    this->precision_));
+      break;
+    case stringValue: {
+      // Is NULL is possible for value.string_? No.
+      char const* str;
+      char const* end;
+      bool ok = value.getString(&str, &end);
+      if (ok)
+        this->pushValue(
+          valueToQuotedStringN(str, static_cast<unsigned>(end - str)));
+      else
+        this->pushValue("");
+      break;
+    }
+    case booleanValue:
+      this->pushValue(valueToString(value.asBool()));
+      break;
+    case arrayValue:
+      this->writeArrayValue(value);
+      break;
+    case objectValue: {
+      Value::Members members(value.getMemberNames());
+      if (members.empty())
+        this->pushValue("{}");
+      else {
+        this->writeWithIndent("{");
+        this->indent();
+        Value::Members::iterator it = members.begin();
+        for (;;) {
+          JSONCPP_STRING const& name = *it;
+          Value const& childValue = value[name];
+          this->writeCommentBeforeValue(childValue);
+          this->writeWithIndent(valueToQuotedStringN(
+            name.data(), static_cast<unsigned>(name.length())));
+          *this->sout_ << this->colonSymbol_;
+          this->writeValue(childValue);
+          if (++it == members.end()) {
+            this->writeCommentAfterValueOnSameLine(childValue);
+            break;
+          }
+          *this->sout_ << ",";
+          this->writeCommentAfterValueOnSameLine(childValue);
         }
-        *sout_ << ",";
-        writeCommentAfterValueOnSameLine(childValue);
+        this->unindent();
+        this->writeWithIndent("}");
       }
-      unindent();
-      writeWithIndent("}");
-    }
-  } break;
+    } break;
   }
 }
 
-void BuiltStyledStreamWriter::writeArrayValue(Value const& value) {
+void BuiltStyledStreamWriter::writeArrayValue(Value const& value)
+{
   unsigned size = value.size();
   if (size == 0)
-    pushValue("[]");
+    this->pushValue("[]");
   else {
-    bool isMultiLine = (cs_ == CommentStyle::All) || isMultineArray(value);
+    bool isMultiLine =
+      (this->cs_ == CommentStyle::All) || this->isMultineArray(value);
     if (isMultiLine) {
-      writeWithIndent("[");
-      indent();
-      bool hasChildValue = !childValues_.empty();
+      this->writeWithIndent("[");
+      this->indent();
+      bool hasChildValue = !this->childValues_.empty();
       unsigned index = 0;
       for (;;) {
         Value const& childValue = value[index];
-        writeCommentBeforeValue(childValue);
+        this->writeCommentBeforeValue(childValue);
         if (hasChildValue)
-          writeWithIndent(childValues_[index]);
+          this->writeWithIndent(this->childValues_[index]);
         else {
-          if (!indented_) writeIndent();
-          indented_ = true;
-          writeValue(childValue);
-          indented_ = false;
+          if (!this->indented_)
+            this->writeIndent();
+          this->indented_ = true;
+          this->writeValue(childValue);
+          this->indented_ = false;
         }
         if (++index == size) {
-          writeCommentAfterValueOnSameLine(childValue);
+          this->writeCommentAfterValueOnSameLine(childValue);
           break;
         }
-        *sout_ << ",";
-        writeCommentAfterValueOnSameLine(childValue);
+        *this->sout_ << ",";
+        this->writeCommentAfterValueOnSameLine(childValue);
       }
-      unindent();
-      writeWithIndent("]");
+      this->unindent();
+      this->writeWithIndent("]");
     } else // output on a single line
     {
-      assert(childValues_.size() == size);
-      *sout_ << "[";
-      if (!indentation_.empty()) *sout_ << " ";
+      assert(this->childValues_.size() == size);
+      *this->sout_ << "[";
+      if (!this->indentation_.empty())
+        *this->sout_ << " ";
       for (unsigned index = 0; index < size; ++index) {
         if (index > 0)
-          *sout_ << ((!indentation_.empty()) ? ", " : ",");
-        *sout_ << childValues_[index];
+          *this->sout_ << ((!this->indentation_.empty()) ? ", " : ",");
+        *this->sout_ << this->childValues_[index];
       }
-      if (!indentation_.empty()) *sout_ << " ";
-      *sout_ << "]";
+      if (!this->indentation_.empty())
+        *this->sout_ << " ";
+      *this->sout_ << "]";
     }
   }
 }
 
-bool BuiltStyledStreamWriter::isMultineArray(Value const& value) {
+bool BuiltStyledStreamWriter::isMultineArray(Value const& value)
+{
   ArrayIndex const size = value.size();
-  bool isMultiLine = size * 3 >= rightMargin_;
-  childValues_.clear();
+  bool isMultiLine = size * 3 >= this->rightMargin_;
+  this->childValues_.clear();
   for (ArrayIndex index = 0; index < size && !isMultiLine; ++index) {
     Value const& childValue = value[index];
     isMultiLine = ((childValue.isArray() || childValue.isObject()) &&
-                        childValue.size() > 0);
+                   childValue.size() > 0);
   }
   if (!isMultiLine) // check if line length > max line length
   {
-    childValues_.reserve(size);
-    addChildValues_ = true;
+    this->childValues_.reserve(size);
+    this->addChildValues_ = true;
     ArrayIndex lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]'
     for (ArrayIndex index = 0; index < size; ++index) {
       if (hasCommentForValue(value[index])) {
         isMultiLine = true;
       }
-      writeValue(value[index]);
-      lineLength += static_cast<ArrayIndex>(childValues_[index].length());
+      this->writeValue(value[index]);
+      lineLength +=
+        static_cast<ArrayIndex>(this->childValues_[index].length());
     }
-    addChildValues_ = false;
-    isMultiLine = isMultiLine || lineLength >= rightMargin_;
+    this->addChildValues_ = false;
+    isMultiLine = isMultiLine || lineLength >= this->rightMargin_;
   }
   return isMultiLine;
 }
 
-void BuiltStyledStreamWriter::pushValue(JSONCPP_STRING const& value) {
-  if (addChildValues_)
-    childValues_.push_back(value);
+void BuiltStyledStreamWriter::pushValue(JSONCPP_STRING const& value)
+{
+  if (this->addChildValues_)
+    this->childValues_.push_back(value);
   else
-    *sout_ << value;
+    *this->sout_ << value;
 }
 
-void BuiltStyledStreamWriter::writeIndent() {
+void BuiltStyledStreamWriter::writeIndent()
+{
   // blep intended this to look at the so-far-written string
   // to determine whether we are already indented, but
   // with a stream we cannot do that. So we rely on some saved state.
   // The caller checks indented_.
 
-  if (!indentation_.empty()) {
+  if (!this->indentation_.empty()) {
     // In this case, drop newlines too.
-    *sout_ << '\n' << indentString_;
+    *this->sout_ << '\n' << this->indentString_;
   }
 }
 
-void BuiltStyledStreamWriter::writeWithIndent(JSONCPP_STRING const& value) {
-  if (!indented_) writeIndent();
-  *sout_ << value;
-  indented_ = false;
+void BuiltStyledStreamWriter::writeWithIndent(JSONCPP_STRING const& value)
+{
+  if (!this->indented_)
+    this->writeIndent();
+  *this->sout_ << value;
+  this->indented_ = false;
 }
 
-void BuiltStyledStreamWriter::indent() { indentString_ += indentation_; }
+void BuiltStyledStreamWriter::indent()
+{
+  this->indentString_ += this->indentation_;
+}
 
-void BuiltStyledStreamWriter::unindent() {
-  assert(indentString_.size() >= indentation_.size());
-  indentString_.resize(indentString_.size() - indentation_.size());
+void BuiltStyledStreamWriter::unindent()
+{
+  assert(this->indentString_.size() >= this->indentation_.size());
+  this->indentString_.resize(this->indentString_.size() -
+                             this->indentation_.size());
 }
 
-void BuiltStyledStreamWriter::writeCommentBeforeValue(Value const& root) {
-  if (cs_ == CommentStyle::None) return;
+void BuiltStyledStreamWriter::writeCommentBeforeValue(Value const& root)
+{
+  if (this->cs_ == CommentStyle::None)
+    return;
   if (!root.hasComment(commentBefore))
     return;
 
-  if (!indented_) writeIndent();
+  if (!this->indented_)
+    this->writeIndent();
   const JSONCPP_STRING& comment = root.getComment(commentBefore);
   JSONCPP_STRING::const_iterator iter = comment.begin();
   while (iter != comment.end()) {
-    *sout_ << *iter;
-    if (*iter == '\n' &&
-       (iter != comment.end() && *(iter + 1) == '/'))
+    *this->sout_ << *iter;
+    if (*iter == '\n' && (iter != comment.end() && *(iter + 1) == '/'))
       // writeIndent();  // would write extra newline
-      *sout_ << indentString_;
+      *this->sout_ << this->indentString_;
     ++iter;
   }
-  indented_ = false;
+  this->indented_ = false;
 }
 
-void BuiltStyledStreamWriter::writeCommentAfterValueOnSameLine(Value const& root) {
-  if (cs_ == CommentStyle::None) return;
+void BuiltStyledStreamWriter::writeCommentAfterValueOnSameLine(
+  Value const& root)
+{
+  if (this->cs_ == CommentStyle::None)
+    return;
   if (root.hasComment(commentAfterOnSameLine))
-    *sout_ << " " + root.getComment(commentAfterOnSameLine);
+    *this->sout_ << " " + root.getComment(commentAfterOnSameLine);
 
   if (root.hasComment(commentAfter)) {
-    writeIndent();
-    *sout_ << root.getComment(commentAfter);
+    this->writeIndent();
+    *this->sout_ << root.getComment(commentAfter);
   }
 }
 
 // static
-bool BuiltStyledStreamWriter::hasCommentForValue(const Value& value) {
+bool BuiltStyledStreamWriter::hasCommentForValue(const Value& value)
+{
   return value.hasComment(commentBefore) ||
-         value.hasComment(commentAfterOnSameLine) ||
-         value.hasComment(commentAfter);
+    value.hasComment(commentAfterOnSameLine) || value.hasComment(commentAfter);
 }
 
 ///////////////
 // StreamWriter
 
 StreamWriter::StreamWriter()
-    : sout_(NULL)
+  : sout_(NULL)
 {
 }
 StreamWriter::~StreamWriter()
 {
 }
 StreamWriter::Factory::~Factory()
-{}
+{
+}
 StreamWriterBuilder::StreamWriterBuilder()
 {
-  setDefaults(&settings_);
+  setDefaults(&this->settings_);
 }
 StreamWriterBuilder::~StreamWriterBuilder()
-{}
+{
+}
 StreamWriter* StreamWriterBuilder::newStreamWriter() const
 {
-  JSONCPP_STRING indentation = settings_["indentation"].asString();
-  JSONCPP_STRING cs_str = settings_["commentStyle"].asString();
-  bool eyc = settings_["enableYAMLCompatibility"].asBool();
-  bool dnp = settings_["dropNullPlaceholders"].asBool();
-  bool usf = settings_["useSpecialFloats"].asBool(); 
-  unsigned int pre = settings_["precision"].asUInt();
+  JSONCPP_STRING indentation = this->settings_["indentation"].asString();
+  JSONCPP_STRING cs_str = this->settings_["commentStyle"].asString();
+  bool eyc = this->settings_["enableYAMLCompatibility"].asBool();
+  bool dnp = this->settings_["dropNullPlaceholders"].asBool();
+  bool usf = this->settings_["useSpecialFloats"].asBool();
+  unsigned int pre = this->settings_["precision"].asUInt();
   CommentStyle::Enum cs = CommentStyle::All;
   if (cs_str == "All") {
     cs = CommentStyle::All;
@@ -1191,11 +1301,11 @@ StreamWriter* StreamWriterBuilder::newStreamWriter() const
   if (dnp) {
     nullSymbol.clear();
   }
-  if (pre > 17) pre = 17;
+  if (pre > 17)
+    pre = 17;
   JSONCPP_STRING endingLineFeedSymbol;
-  return new BuiltStyledStreamWriter(
-      indentation, cs,
-      colonSymbol, nullSymbol, endingLineFeedSymbol, usf, pre);
+  return new BuiltStyledStreamWriter(indentation, cs, colonSymbol, nullSymbol,
+                                     endingLineFeedSymbol, usf, pre);
 }
 static void getValidWriterKeys(std::set<JSONCPP_STRING>* valid_keys)
 {
@@ -1210,23 +1320,24 @@ static void getValidWriterKeys(std::set<JSONCPP_STRING>* valid_keys)
 bool StreamWriterBuilder::validate(Json::Value* invalid) const
 {
   Json::Value my_invalid;
-  if (!invalid) invalid = &my_invalid;  // so we do not need to test for NULL
+  if (!invalid)
+    invalid = &my_invalid; // so we do not need to test for NULL
   Json::Value& inv = *invalid;
   std::set<JSONCPP_STRING> valid_keys;
   getValidWriterKeys(&valid_keys);
-  Value::Members keys = settings_.getMemberNames();
+  Value::Members keys = this->settings_.getMemberNames();
   size_t n = keys.size();
   for (size_t i = 0; i < n; ++i) {
     JSONCPP_STRING const& key = keys[i];
     if (valid_keys.find(key) == valid_keys.end()) {
-      inv[key] = settings_[key];
+      inv[key] = this->settings_[key];
     }
   }
   return 0u == inv.size();
 }
 Value& StreamWriterBuilder::operator[](JSONCPP_STRING key)
 {
-  return settings_[key];
+  return this->settings_[key];
 }
 // static
 void StreamWriterBuilder::setDefaults(Json::Value* settings)
@@ -1241,14 +1352,17 @@ void StreamWriterBuilder::setDefaults(Json::Value* settings)
   //! [StreamWriterBuilderDefaults]
 }
 
-JSONCPP_STRING writeString(StreamWriter::Factory const& builder, Value const& root) {
+JSONCPP_STRING writeString(StreamWriter::Factory const& builder,
+                           Value const& root)
+{
   JSONCPP_OSTRINGSTREAM sout;
   StreamWriterPtr const writer(builder.newStreamWriter());
   writer->write(root, &sout);
   return sout.str();
 }
 
-JSONCPP_OSTREAM& operator<<(JSONCPP_OSTREAM& sout, Value const& root) {
+JSONCPP_OSTREAM& operator<<(JSONCPP_OSTREAM& sout, Value const& root)
+{
   StreamWriterBuilder builder;
   StreamWriterPtr const writer(builder.newStreamWriter());
   writer->write(root, &sout);