diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 073630e..680d77b 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -284,6 +284,29 @@
     variables:
         RSYNC_DESTINATION: dev
 
+build:macos10.10-package:
+    extends:
+        - .macos10.10_package
+        - .cmake_build_macos_package
+        - .cmake_release_artifacts
+        - .macos_builder_tags_package
+        - .run_only_for_package
+    dependencies:
+        - prep:doc-package
+    needs:
+        - prep:doc-package
+
+upload:macos10.10-package:
+    extends:
+        - .rsync_upload
+        - .run_only_for_package
+    dependencies:
+        - build:macos10.10-package
+    needs:
+        - build:macos10.10-package
+    variables:
+        RSYNC_DESTINATION: dev
+
 # Windows builds
 
 build:windows-vs2019-x64-ninja:
diff --git a/.gitlab/artifacts.yml b/.gitlab/artifacts.yml
index 76ffd27..87828e1 100644
--- a/.gitlab/artifacts.yml
+++ b/.gitlab/artifacts.yml
@@ -75,7 +75,7 @@
             # Any packages made.
             - build/cmake-*-Linux-x86_64.*
             - build/cmake-*-Linux-aarch64.*
-            - build/cmake-*-macos-universal.*
+            - build/cmake-*-macos*-universal.*
             # Any source packages made.
             - build/cmake-*.tar.gz
             - build/cmake-*.zip
diff --git a/.gitlab/ci/configure_macos10.10_package.cmake b/.gitlab/ci/configure_macos10.10_package.cmake
new file mode 100644
index 0000000..f01e6c8
--- /dev/null
+++ b/.gitlab/ci/configure_macos10.10_package.cmake
@@ -0,0 +1,4 @@
+set(CPACK_SYSTEM_NAME "macos10.10-universal" CACHE STRING "")
+set(CMAKE_OSX_DEPLOYMENT_TARGET "10.10" CACHE STRING "")
+
+include("${CMAKE_CURRENT_LIST_DIR}/configure_macos_package_common.cmake")
diff --git a/.gitlab/ci/configure_macos_package.cmake b/.gitlab/ci/configure_macos_package.cmake
index a1dbdb9..380e44c 100644
--- a/.gitlab/ci/configure_macos_package.cmake
+++ b/.gitlab/ci/configure_macos_package.cmake
@@ -1,28 +1,4 @@
-set(CMake_DOC_ARTIFACT_PREFIX "$ENV{CI_PROJECT_DIR}/build/install-doc" CACHE PATH "")
-
-# Set up install destinations as expected by the packaging scripts.
-set(CMAKE_INSTALL_PREFIX "/" CACHE PATH "")
-set(CMAKE_DOC_DIR "doc/cmake" CACHE STRING "")
-
-# Settings for CMake packages for macOS.
-set(CPACK_DMG_FORMAT "UDBZ" CACHE STRING "")
-set(CMAKE_CXX_FLAGS "-stdlib=libc++" CACHE STRING "")
-set(CMAKE_C_STANDARD "11" CACHE STRING "")
-set(CMAKE_CXX_STANDARD "14" CACHE STRING "")
-set(CMAKE_OSX_ARCHITECTURES "x86_64;arm64" CACHE STRING "")
-set(CMAKE_OSX_DEPLOYMENT_TARGET "10.10" CACHE STRING "")
-set(CMAKE_SKIP_BOOTSTRAP_TEST "TRUE" CACHE STRING "")
 set(CPACK_SYSTEM_NAME "macos-universal" CACHE STRING "")
-set(BUILD_CursesDialog "ON" CACHE BOOL "")
-set(BUILD_QtDialog "TRUE" CACHE BOOL "")
-set(CMake_GUI_DISTRIBUTE_WITH_Qt_LGPL "3" CACHE STRING "")
-set(CMake_INSTALL_DEPENDENCIES "ON" CACHE BOOL "")
-set(CMAKE_SKIP_RPATH "TRUE" CACHE BOOL "")
-set(CMake_TEST_NO_FindPackageModeMakefileTest "TRUE" CACHE BOOL "")
+set(CMAKE_OSX_DEPLOYMENT_TARGET "10.13" CACHE STRING "")
 
-# XXX(sccache): restore sccache when it works for multiple architectures:
-# https://github.com/mozilla/sccache/issues/847
-set(configure_no_sccache 1)
-
-include("${CMAKE_CURRENT_LIST_DIR}/configure_macos_common.cmake")
-include("${CMAKE_CURRENT_LIST_DIR}/configure_common.cmake")
+include("${CMAKE_CURRENT_LIST_DIR}/configure_macos_package_common.cmake")
diff --git a/.gitlab/ci/configure_macos_package_common.cmake b/.gitlab/ci/configure_macos_package_common.cmake
new file mode 100644
index 0000000..3aa8ae2
--- /dev/null
+++ b/.gitlab/ci/configure_macos_package_common.cmake
@@ -0,0 +1,26 @@
+set(CMake_DOC_ARTIFACT_PREFIX "$ENV{CI_PROJECT_DIR}/build/install-doc" CACHE PATH "")
+
+# Set up install destinations as expected by the packaging scripts.
+set(CMAKE_INSTALL_PREFIX "/" CACHE PATH "")
+set(CMAKE_DOC_DIR "doc/cmake" CACHE STRING "")
+
+# Settings for CMake packages for macOS.
+set(CPACK_DMG_FORMAT "UDBZ" CACHE STRING "")
+set(CMAKE_CXX_FLAGS "-stdlib=libc++" CACHE STRING "")
+set(CMAKE_C_STANDARD "11" CACHE STRING "")
+set(CMAKE_CXX_STANDARD "14" CACHE STRING "")
+set(CMAKE_OSX_ARCHITECTURES "x86_64;arm64" CACHE STRING "")
+set(CMAKE_SKIP_BOOTSTRAP_TEST "TRUE" CACHE STRING "")
+set(BUILD_CursesDialog "ON" CACHE BOOL "")
+set(BUILD_QtDialog "TRUE" CACHE BOOL "")
+set(CMake_GUI_DISTRIBUTE_WITH_Qt_LGPL "3" CACHE STRING "")
+set(CMake_INSTALL_DEPENDENCIES "ON" CACHE BOOL "")
+set(CMAKE_SKIP_RPATH "TRUE" CACHE BOOL "")
+set(CMake_TEST_NO_FindPackageModeMakefileTest "TRUE" CACHE BOOL "")
+
+# XXX(sccache): restore sccache when it works for multiple architectures:
+# https://github.com/mozilla/sccache/issues/847
+set(configure_no_sccache 1)
+
+include("${CMAKE_CURRENT_LIST_DIR}/configure_macos_common.cmake")
+include("${CMAKE_CURRENT_LIST_DIR}/configure_common.cmake")
diff --git a/.gitlab/ci/download_qt.cmake b/.gitlab/ci/download_qt.cmake
index 4a33f12..76c693d 100644
--- a/.gitlab/ci/download_qt.cmake
+++ b/.gitlab/ci/download_qt.cmake
@@ -48,7 +48,11 @@
 
   set(qt_subdir "${qt_version}/msvc${msvc_year}_64")
 elseif (qt_platform STREQUAL "mac_x64")
-  if ("$ENV{CMAKE_CONFIGURATION}" MATCHES "package")
+  if ("$ENV{CMAKE_CONFIGURATION}" MATCHES "macos_package")
+    list(APPEND qt_files
+      "qt-5.15.2-macosx10.13-x86_64-arm64.tar.xz")
+    set(qt_subdir "qt-5.15.2-macosx10.13-x86_64-arm64")
+  elseif ("$ENV{CMAKE_CONFIGURATION}" MATCHES "macos10.10_package")
     list(APPEND qt_files
       "qt-5.9.9-macosx10.10-x86_64-arm64.tar.xz")
     set(qt_subdir "qt-5.9.9-macosx10.10-x86_64-arm64")
diff --git a/.gitlab/ci/download_qt_hashes.cmake b/.gitlab/ci/download_qt_hashes.cmake
index 832fa98..afbc081 100644
--- a/.gitlab/ci/download_qt_hashes.cmake
+++ b/.gitlab/ci/download_qt_hashes.cmake
@@ -11,3 +11,4 @@
 set("5.15.1-0-202009071110qtbase-MacOS-MacOS_10_13-Clang-MacOS-MacOS_10_13-X86_64.7z_hash" df2813ce7c6cb4287abd7956cd1cb9d08312e4ac1208b6cb57af4df11b8ebba1)
 
 set("qt-5.9.9-macosx10.10-x86_64-arm64.tar.xz_hash" d4449771afa0bc6a809c14f1e6d939e7732494cf059503ae451e2bfe8fc60cc1)
+set("qt-5.15.2-macosx10.13-x86_64-arm64.tar.xz_hash" 7b9463a01c8beeee5bf8d01c70deff2d08561cd20aaf6f7a2f41cf8b68ce8a6b)
diff --git a/.gitlab/os-macos.yml b/.gitlab/os-macos.yml
index 8a006b1..450bae7 100644
--- a/.gitlab/os-macos.yml
+++ b/.gitlab/os-macos.yml
@@ -7,7 +7,7 @@
         GIT_CLONE_PATH: "$CI_BUILDS_DIR/cmake ci ext/$CI_CONCURRENT_ID"
         # TODO: Factor this out so that each job selects the Xcode version to
         # use so that different versions can be tested in a single pipeline.
-        DEVELOPER_DIR: "/Applications/Xcode-12.2.app/Contents/Developer"
+        DEVELOPER_DIR: "/Applications/Xcode-12.3.app/Contents/Developer"
         # Avoid conflicting with other projects running on the same machine.
         SCCACHE_SERVER_PORT: 4227
 
@@ -47,6 +47,14 @@
         CTEST_NO_WARNINGS_ALLOWED: 1
         CMake_SKIP_INSTALL: 1
 
+.macos10.10_package:
+    extends: .macos_build
+
+    variables:
+        CMAKE_CONFIGURATION: macos10.10_package
+        CTEST_NO_WARNINGS_ALLOWED: 1
+        CMake_SKIP_INSTALL: 1
+
 ### External testing
 
 .macos_xcode:
@@ -63,7 +71,7 @@
         - cmake # Since this is a bare runner, pin to a project.
         - macos
         - shell
-        - xcode-12.2
+        - xcode-12.3
         - nonconcurrent
 
 .macos_builder_tags_package:
@@ -71,7 +79,7 @@
         - cmake # Since this is a bare runner, pin to a project.
         - macos
         - shell
-        - xcode-12.2
+        - xcode-12.3
         - nonconcurrent
         - finder
 
@@ -80,7 +88,7 @@
         - cmake # Since this is a bare runner, pin to a project.
         - macos
         - shell
-        - xcode-12.2
+        - xcode-12.3
         - concurrent
 
 ## macOS-specific scripts
diff --git a/.gitlab/upload.yml b/.gitlab/upload.yml
index 6bfa763..8b8daa1 100644
--- a/.gitlab/upload.yml
+++ b/.gitlab/upload.yml
@@ -15,4 +15,4 @@
         - dnf install -y --setopt=install_weak_deps=False rsync openssh-clients
         - chmod 400 $RSYNC_BINARY_KEY
         - ssh-keygen -y -f $RSYNC_BINARY_KEY > $RSYNC_BINARY_KEY.pub
-        - rsync -tv --recursive -e "ssh -i $RSYNC_BINARY_KEY -o StrictHostKeyChecking=no -o LogLevel=ERROR" build/ kitware@public.kitware.com:$RSYNC_DESTINATION/
+        - rsync -tv --recursive -e "ssh -i $RSYNC_BINARY_KEY -o StrictHostKeyChecking=no -o LogLevel=ERROR" build/ kitware@cmake.org:$RSYNC_DESTINATION/
diff --git a/Help/command/if.rst b/Help/command/if.rst
index 72d328d..c51d2bc 100644
--- a/Help/command/if.rst
+++ b/Help/command/if.rst
@@ -47,7 +47,8 @@
 and ``MATCHES``.  Then the boolean operators in the order ``NOT``,  ``AND``,
 and finally ``OR``.
 
-Possible conditions are:
+Basic Expressions
+"""""""""""""""""
 
 ``if(<constant>)``
  True if the constant is ``1``, ``ON``, ``YES``, ``TRUE``, ``Y``,
@@ -62,6 +63,9 @@
  True if given a variable that is defined to a value that is not a false
  constant.  False otherwise.  (Note macro arguments are not variables.)
 
+Logic Operators
+"""""""""""""""
+
 ``if(NOT <condition>)``
  True if the condition is not true.
 
@@ -71,6 +75,15 @@
 ``if(<cond1> OR <cond2>)``
  True if either condition would be considered true individually.
 
+``if((condition) AND (condition OR (condition)))``
+ The conditions inside the parenthesis are evaluated first and then
+ the remaining condition is evaluated as in the other examples.
+ Where there are nested parenthesis the innermost are evaluated as part
+ of evaluating the condition that contains them.
+
+Existence Checks
+""""""""""""""""
+
 ``if(COMMAND command-name)``
  True if the given name is a command, macro or function that can be
  invoked.
@@ -89,6 +102,21 @@
   True if the given name is an existing test name created by the
   :command:`add_test` command.
 
+``if(DEFINED <name>|CACHE{<name>}|ENV{<name>})``
+ True if a variable, cache variable or environment variable
+ with given ``<name>`` is defined. The value of the variable
+ does not matter. Note that macro arguments are not variables.
+
+ .. versionadded:: 3.14
+  Added support for ``CACHE{<name>}`` variables.
+
+``if(<variable|string> IN_LIST <variable>)``
+ .. versionadded:: 3.3
+  True if the given element is contained in the named list variable.
+
+File Operations
+"""""""""""""""
+
 ``if(EXISTS path-to-file-or-directory)``
  True if the named file or directory exists.  Behavior is well-defined
  only for full paths. Resolves symbolic links, i.e. if the named file or
@@ -114,6 +142,9 @@
 ``if(IS_ABSOLUTE path)``
  True if the given path is an absolute path.
 
+Comparisons
+"""""""""""
+
 ``if(<variable|string> MATCHES regex)``
  True if the given string or variable's value matches the given regular
  condition.  See :ref:`Regex Specification` for regex format.
@@ -165,6 +196,9 @@
   True if the given string or variable's value is lexicographically greater
   than or equal to the string or variable on the right.
 
+Version Comparisons
+"""""""""""""""""""
+
 ``if(<variable|string> VERSION_LESS <variable|string>)``
  Component-wise integer version number comparison (version format is
  ``major[.minor[.patch[.tweak]]]``, omitted components are treated as zero).
@@ -197,24 +231,6 @@
   Any non-integer version component or non-integer trailing part of a version
   component effectively truncates the string at that point.
 
-``if(<variable|string> IN_LIST <variable>)``
- .. versionadded:: 3.3
-  True if the given element is contained in the named list variable.
-
-``if(DEFINED <name>|CACHE{<name>}|ENV{<name>})``
- True if a variable, cache variable or environment variable
- with given ``<name>`` is defined. The value of the variable
- does not matter. Note that macro arguments are not variables.
-
- .. versionadded:: 3.14
-  Added support for ``CACHE{<name>}`` variables.
-
-``if((condition) AND (condition OR (condition)))``
- The conditions inside the parenthesis are evaluated first and then
- the remaining condition is evaluated as in the previous examples.
- Where there are nested parenthesis the innermost are evaluated as part
- of evaluating the condition that contains them.
-
 Variable Expansion
 ^^^^^^^^^^^^^^^^^^
 
diff --git a/Help/command/install.rst b/Help/command/install.rst
index bd8da39..35207f4 100644
--- a/Help/command/install.rst
+++ b/Help/command/install.rst
@@ -473,6 +473,11 @@
   use "generator expressions" with the syntax ``$<...>``.  See the
   :manual:`cmake-generator-expressions(7)` manual for available expressions.
 
+.. versionadded:: 3.20
+  An install rename given as a ``RENAME`` argument may
+  use "generator expressions" with the syntax ``$<...>``.  See the
+  :manual:`cmake-generator-expressions(7)` manual for available expressions.
+
 Installing Directories
 ^^^^^^^^^^^^^^^^^^^^^^
 
diff --git a/Help/dev/experimental.rst b/Help/dev/experimental.rst
index 4d2b076..d019161 100644
--- a/Help/dev/experimental.rst
+++ b/Help/dev/experimental.rst
@@ -7,4 +7,64 @@
 
 .. _`CMake Development`: README.rst
 
-No experimental features are under development in this version of CMake.
+C++20 Module Dependencies
+=========================
+
+The Ninja generator has experimental infrastructure supporting C++20 module
+dependency scanning.  This is similar to the Fortran modules support, but
+relies on external tools to scan C++20 translation units for module
+dependencies.  The approach is described by Kitware's `D1483r1`_ paper.
+
+The ``CMAKE_EXPERIMENTAL_CXX_MODULE_DYNDEP`` variable can be set to ``1``
+in order to activate this undocumented experimental infrastructure.  This
+is **intended to make the functionality available to compiler writers** so
+they can use it to develop and test their dependency scanning tool.
+The ``CMAKE_EXPERIMENTAL_CXX_SCANDEP_SOURCE`` variable must also be set
+to tell CMake how to invoke the C++20 module dependency scanning tool.
+
+For example, add code like the following to a test project:
+
+.. code-block:: cmake
+
+  set(CMAKE_EXPERIMENTAL_CXX_MODULE_DYNDEP 1)
+  string(CONCAT CMAKE_EXPERIMENTAL_CXX_SCANDEP_SOURCE
+    "<CMAKE_CXX_COMPILER> <DEFINES> <INCLUDES> <FLAGS> <SOURCE>"
+    " -MT <DYNDEP_FILE> -MD -MF <DEP_FILE>"
+    " ${flags_to_scan_deps} -fdep-file=<DYNDEP_FILE> -fdep-output=<OBJECT>"
+    )
+
+The tool specified by ``CMAKE_EXPERIMENTAL_CXX_SCANDEP_SOURCE`` is
+expected to process the translation unit, write preprocessor dependencies
+to the file specified by the ``<DEP_FILE>`` placeholder, and write module
+dependencies to the file specified by the ``<DYNDEP_FILE>`` placeholder.
+
+The module dependencies should be written in the format described
+by the `P1689r3`_ paper.
+
+Compiler writers may try out their scanning functionality using
+the `cxx-modules-sandbox`_ test project, modified to set variables
+as above for their compiler.
+
+For compilers that generate module maps, tell CMake as follows:
+
+.. code-block:: cmake
+
+  set(CMAKE_EXPERIMENTAL_CXX_MODULE_MAP_FORMAT "gcc")
+  set(CMAKE_EXPERIMENTAL_CXX_MODULE_MAP_FLAG
+    "${compiler_flags_for_module_map} -fmodule-mapper=<MODULE_MAP_FILE>")
+
+Currently, the only supported format is ``gcc``.  The format is described in
+the GCC documentation, but the relevant section for the purposes of CMake is:
+
+    A mapping file consisting of space-separated module-name, filename
+    pairs, one per line.  Only the mappings for the direct imports and any
+    module export name need be provided.  If other mappings are provided,
+    they override those stored in any imported CMI files.  A repository
+    root may be specified in the mapping file by using ``$root`` as the
+    module name in the first active line.
+
+    -- GCC module mapper documentation
+
+.. _`D1483r1`: https://mathstuf.fedorapeople.org/fortran-modules/fortran-modules.html
+.. _`P1689r3`: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p1689r3.html
+.. _`cxx-modules-sandbox`: https://github.com/mathstuf/cxx-modules-sandbox
diff --git a/Help/generator/Ninja Multi-Config.rst b/Help/generator/Ninja Multi-Config.rst
index d1df42b..8901192 100644
--- a/Help/generator/Ninja Multi-Config.rst
+++ b/Help/generator/Ninja Multi-Config.rst
@@ -130,3 +130,34 @@
 the ``generator`` target is called with ``Debug.txt Debug Release`` as
 arguments. The command depends on the ``Release`` builds of ``tgt1`` and
 ``tgt4``, and the ``Debug`` builds of ``tgt2`` and ``tgt3``.
+
+``PRE_BUILD``, ``PRE_LINK``, and ``POST_BUILD`` custom commands for targets
+only get run in their "native" configuration (the ``Release`` configuration in
+the ``build-Release.ninja`` file) unless they have no ``BYPRODUCTS`` or their
+``BYPRODUCTS`` are unique per config. Consider the following example:
+
+.. code-block:: cmake
+
+  add_executable(exe main.c)
+  add_custom_command(
+    TARGET exe
+    POST_BUILD
+    COMMAND ${CMAKE_COMMAND} -E echo "Running no-byproduct command"
+    )
+  add_custom_command(
+    TARGET exe
+    POST_BUILD
+    COMMAND ${CMAKE_COMMAND} -E echo "Running separate-byproduct command for $<CONFIG>"
+    BYPRODUCTS $<CONFIG>.txt
+    )
+  add_custom_command(
+    TARGET exe
+    POST_BUILD
+    COMMAND ${CMAKE_COMMAND} -E echo "Running common-byproduct command for $<CONFIG>"
+    BYPRODUCTS exe.txt
+    )
+
+In this example, if you build ``exe:Debug`` in ``build-Release.ninja``, the
+first and second custom commands get run, since their byproducts are unique
+per-config, but the last custom command does not. However, if you build
+``exe:Release`` in ``build-Release.ninja``, all three custom commands get run.
diff --git a/Help/guide/importing-exporting/MathFunctions/CMakeLists.txt b/Help/guide/importing-exporting/MathFunctions/CMakeLists.txt
index 13c82dd..9a9e40e 100644
--- a/Help/guide/importing-exporting/MathFunctions/CMakeLists.txt
+++ b/Help/guide/importing-exporting/MathFunctions/CMakeLists.txt
@@ -31,7 +31,7 @@
 install(EXPORT MathFunctionsTargets
         FILE MathFunctionsTargets.cmake
         NAMESPACE MathFunctions::
-        DESTINATION lib/cmake
+        DESTINATION lib/cmake/MathFunctions
 )
 
 # include CMakePackageConfigHelpers macro
@@ -58,14 +58,14 @@
 # create config file
 configure_package_config_file(${CMAKE_CURRENT_SOURCE_DIR}/Config.cmake.in
   "${CMAKE_CURRENT_BINARY_DIR}/MathFunctionsConfig.cmake"
-  INSTALL_DESTINATION lib/cmake
+  INSTALL_DESTINATION lib/cmake/MathFunctions
 )
 
 # install config files
 install(FILES
           "${CMAKE_CURRENT_BINARY_DIR}/MathFunctionsConfig.cmake"
           "${CMAKE_CURRENT_BINARY_DIR}/MathFunctionsConfigVersion.cmake"
-        DESTINATION lib/cmake
+        DESTINATION lib/cmake/MathFunctions
 )
 
 # generate the export targets for the build tree
diff --git a/Help/manual/cmake-developer.7.rst b/Help/manual/cmake-developer.7.rst
index 85ed935..af9a8ab 100644
--- a/Help/manual/cmake-developer.7.rst
+++ b/Help/manual/cmake-developer.7.rst
@@ -23,15 +23,14 @@
 Find Modules
 ============
 
-A "find module" is a ``Find<PackageName>.cmake`` file to be loaded
-by the :command:`find_package` command when invoked for ``<PackageName>``.
+A "find module" is a ``Find<PackageName>.cmake`` file to be loaded by the
+:command:`find_package` command when invoked for ``<PackageName>``.
 
-The primary task of a find module is to determine whether a package
-exists on the system, set the ``<PackageName>_FOUND`` variable to reflect
-this and provide any variables, macros and imported targets required to
-use the package.  A find module is useful in cases where an upstream
-library does not provide a
-:ref:`config file package <Config File Packages>`.
+The primary task of a find module is to determine whether a package is
+available, set the ``<PackageName>_FOUND`` variable to reflect this and
+provide any variables, macros and imported targets required to use the
+package.  A find module is useful in cases where an upstream library does
+not provide a :ref:`config file package <Config File Packages>`.
 
 The traditional approach is to use variables for everything, including
 libraries and executables: see the `Standard Variable Names`_ section
@@ -91,55 +90,92 @@
 For a ``FindXxx.cmake`` module that takes the approach of setting
 variables (either instead of or in addition to creating imported
 targets), the following variable names should be used to keep things
-consistent between find modules.  Note that all variables start with
-``Xxx_`` to make sure they do not interfere with other find modules; the
-same consideration applies to macros, functions and imported targets.
+consistent between Find modules.  Note that all variables start with
+``Xxx_``, which (unless otherwise noted) must match exactly the name
+of the ``FindXxx.cmake`` file, including upper/lowercase.
+This prefix on the variable names ensures that they do not conflict with
+variables of other Find modules.  The same pattern should also be followed
+for any macros, functions and imported targets defined by the Find module.
 
 ``Xxx_INCLUDE_DIRS``
   The final set of include directories listed in one variable for use by
-  client code.  This should not be a cache entry.
+  client code. This should not be a cache entry (note that this also means
+  this variable should not be used as the result variable of a
+  :command:`find_path` command - see ``Xxx_INCLUDE_DIR`` below for that).
 
 ``Xxx_LIBRARIES``
-  The libraries to link against to use Xxx. These should include full
-  paths.  This should not be a cache entry.
+  The libraries to use with the module.  These may be CMake targets, full
+  absolute paths to a library binary or the name of a library that the
+  linker must find in its search path.  This should not be a cache entry
+  (note that this also means this variable should not be used as the
+  result variable of a :command:`find_library` command - see
+  ``Xxx_LIBRARY`` below for that).
 
 ``Xxx_DEFINITIONS``
-  Definitions to use when compiling code that uses Xxx. This really
-  shouldn't include options such as ``-DHAS_JPEG`` that a client
+  The compile definitions to use when compiling code that uses the module.
+  This really shouldn't include options such as ``-DHAS_JPEG`` that a client
   source-code file uses to decide whether to ``#include <jpeg.h>``
 
 ``Xxx_EXECUTABLE``
-  Where to find the Xxx tool.
+  The full absolute path to an executable.  In this case, ``Xxx`` might not
+  be the name of the module, it might be the name of the tool (usually
+  converted to all uppercase), assuming that tool has such a well-known name
+  that it is unlikely that another tool with the same name exists.  It would
+  be appropriate to use this as the result variable of a
+  :command:`find_program` command.
 
-``Xxx_Yyy_EXECUTABLE``
-  Where to find the Yyy tool that comes with Xxx.
+``Xxx_YYY_EXECUTABLE``
+  Similar to ``Xxx_EXECUTABLE`` except here the ``Xxx`` is always the module
+  name and ``YYY`` is the tool name (again, usually fully uppercase).
+  Prefer this form if the tool name is not very widely known or has the
+  potential  to clash with another tool.  For greater consistency, also
+  prefer this form if the module provides more than one executable.
 
 ``Xxx_LIBRARY_DIRS``
   Optionally, the final set of library directories listed in one
-  variable for use by client code.  This should not be a cache entry.
+  variable for use by client code. This should not be a cache entry.
 
 ``Xxx_ROOT_DIR``
-  Where to find the base directory of Xxx.
+  Where to find the base directory of the module.
 
-``Xxx_VERSION_Yy``
-  Expect Version Yy if true. Make sure at most one of these is ever true.
+``Xxx_VERSION_VV``
+  Variables of this form specify whether the ``Xxx`` module being provided
+  is version ``VV`` of the module.  There should not be more than one
+  variable of this form set to true for a given module.  For example, a
+  module ``Barry`` might have evolved over many years and gone through a
+  number of different major versions.  Version 3 of the ``Barry`` module
+  might set the variable ``Barry_VERSION_3`` to true, whereas an older
+  version of the module might set ``Barry_VERSION_2`` to true instead.
+  It would be an error for both ``Barry_VERSION_3`` and ``Barry_VERSION_2``
+  to both be set to true.
 
-``Xxx_WRAP_Yy``
-  If False, do not try to use the relevant CMake wrapping command.
+``Xxx_WRAP_YY``
+  When a variable of this form is set to false, it indicates that the
+  relevant wrapping command should not be used.  The wrapping command
+  depends on the module, it may be implied by the module name or it might
+  be specified by the ``YY`` part of the variable.
 
 ``Xxx_Yy_FOUND``
-  If False, optional Yy part of Xxx system is not available.
+  For variables of this form, ``Yy`` is the name of a component for the
+  module.  It should match exactly one of the valid component names that
+  may be passed to the :command:`find_package` command for the module.
+  If a variable of this form is set to false, it means that the ``Yy``
+  component of module ``Xxx`` was not found or is not available.
+  Variables of this form would typically be used for optional components
+  so that the caller can check whether an optional component is available.
 
 ``Xxx_FOUND``
-  Set to false, or undefined, if we haven't found, or don't want to use
-  Xxx.
+  When the :command:`find_package` command returns to the caller, this
+  variable will be set to true if the module was deemed to have been found
+  successfully.
 
 ``Xxx_NOT_FOUND_MESSAGE``
   Should be set by config-files in the case that it has set
   ``Xxx_FOUND`` to FALSE.  The contained message will be printed by the
   :command:`find_package` command and by
-  ``find_package_handle_standard_args()`` to inform the user about the
-  problem.
+  :command:`find_package_handle_standard_args` to inform the user about the
+  problem.  Use this instead of calling :command:`message` directly to
+  report a reason for failing to find the module or package.
 
 ``Xxx_RUNTIME_LIBRARY_DIRS``
   Optionally, the runtime library search path for use when running an
@@ -160,23 +196,36 @@
 ``Xxx_VERSION_PATCH``
   The patch version of the package found, if any.
 
-The following names should not usually be used in CMakeLists.txt files, but
-are typically cache variables for users to edit and control the
-behaviour of find modules (like entering the path to a library manually)
+The following names should not usually be used in ``CMakeLists.txt`` files.
+They are intended for use by Find modules to specify and cache the locations
+of specific files or directories.  Users are typically able to set and edit
+these variables to control the behavior of Find modules (like entering the
+path to a library manually):
 
 ``Xxx_LIBRARY``
-  The path of the Xxx library (as used with :command:`find_library`, for
-  example).
+  The path of the library.  Use this form only when the module provides a
+  single library.  It is appropriate to use this as the result variable
+  in a :command:`find_library` command.
 
 ``Xxx_Yy_LIBRARY``
-  The path of the Yy library that is part of the Xxx system. It may or
-  may not be required to use Xxx.
+  The path of library ``Yy`` provided by the module ``Xxx``.  Use this form
+  when the module provides more than one library or where other modules may
+  also provide a library of the same name. It is also appropriate to use
+  this form as the result variable in a :command:`find_library` command.
 
 ``Xxx_INCLUDE_DIR``
-  Where to find headers for using the Xxx library.
+  When the module provides only a single library, this variable can be used
+  to specify where to find headers for using the library (or more accurately,
+  the path that consumers of the library should add to their header search
+  path).  It would be appropriate to use this as the result variable in a
+  :command:`find_path` command.
 
 ``Xxx_Yy_INCLUDE_DIR``
-  Where to find headers for using the Yy library of the Xxx system.
+  If the module provides more than one library or where other modules may
+  also provide a library of the same name, this form is recommended for
+  specifying where to find headers for using library ``Yy`` provided by
+  the module.  Again, it would be appropriate to use this as the result
+  variable in a :command:`find_path` command.
 
 To prevent users being overwhelmed with settings to configure, try to
 keep as many options as possible out of the cache, leaving at least one
@@ -185,7 +234,8 @@
 most cache options as advanced.  For packages which provide both debug
 and release binaries, it is common to create cache variables with a
 ``_LIBRARY_<CONFIG>`` suffix, such as ``Foo_LIBRARY_RELEASE`` and
-``Foo_LIBRARY_DEBUG``.
+``Foo_LIBRARY_DEBUG``.  The :module:`SelectLibraryConfigurations` module
+can be helpful for such cases.
 
 While these are the standard variable names, you should provide
 backwards compatibility for any old names that were actually in use.
diff --git a/Help/manual/cmake-properties.7.rst b/Help/manual/cmake-properties.7.rst
index 5dbc1a4..af170da 100644
--- a/Help/manual/cmake-properties.7.rst
+++ b/Help/manual/cmake-properties.7.rst
@@ -196,6 +196,7 @@
    /prop_tgt/EXCLUDE_FROM_ALL
    /prop_tgt/EXCLUDE_FROM_DEFAULT_BUILD
    /prop_tgt/EXCLUDE_FROM_DEFAULT_BUILD_CONFIG
+   /prop_tgt/EXPORT_COMPILE_COMMANDS
    /prop_tgt/EXPORT_NAME
    /prop_tgt/EXPORT_PROPERTIES
    /prop_tgt/FOLDER
diff --git a/Help/prop_tgt/EXPORT_COMPILE_COMMANDS.rst b/Help/prop_tgt/EXPORT_COMPILE_COMMANDS.rst
new file mode 100644
index 0000000..0b1145c
--- /dev/null
+++ b/Help/prop_tgt/EXPORT_COMPILE_COMMANDS.rst
@@ -0,0 +1,9 @@
+EXPORT_COMPILE_COMMANDS
+-----------------------
+
+.. versionadded:: 3.20
+
+Enable/Disable output of compile commands during generation for a target.
+
+This property is initialized by the value of the variable
+:variable:`CMAKE_EXPORT_COMPILE_COMMANDS` if it is set when a target is created.
diff --git a/Help/release/3.19.rst b/Help/release/3.19.rst
index eb49c6f..7ad27c8 100644
--- a/Help/release/3.19.rst
+++ b/Help/release/3.19.rst
@@ -390,3 +390,13 @@
 ------
 
 * A precompiled Linux ``aarch64`` binary is now provided on ``cmake.org``.
+
+* Two precompiled macOS binaries are now provided on ``cmake.org``:
+
+  * The naming pattern ``cmake-$ver-macos-universal`` is a universal
+    binary with ``x86_64`` and ``arm64`` architectures.  It requires
+    macOS 10.13 or newer.
+
+  * The naming pattern ``cmake-$ver-macos10.10-universal`` is a universal
+    binary with ``x86_64`` and ``arm64`` architectures.  It requires
+    macOS 10.10 or newer.
diff --git a/Help/release/dev/Java-export-native_headers-target.rst b/Help/release/dev/Java-export-native_headers-target.rst
new file mode 100644
index 0000000..13b6dfb
--- /dev/null
+++ b/Help/release/dev/Java-export-native_headers-target.rst
@@ -0,0 +1,6 @@
+Java-export-native_headers-target
+---------------------------------
+
+* ``add_jar()`` command, from :module:`UseJava` module, gains new capabilities
+  for ``GENERATE_NATIVE_HEADERS`` option. These capabilities facilitate the
+  exportation of the generated target.
diff --git a/Help/release/dev/cuda-nvcc-ccache-symlink.rst b/Help/release/dev/cuda-nvcc-ccache-symlink.rst
new file mode 100644
index 0000000..4d38047
--- /dev/null
+++ b/Help/release/dev/cuda-nvcc-ccache-symlink.rst
@@ -0,0 +1,9 @@
+cuda-nvcc-ccache-symlink
+------------------------
+
+* ``CUDA`` language support now works when ``nvcc`` is a symbolic link,
+  for example due to a ``ccache`` or ``colornvcc`` wrapper script.
+
+* The :module:`FindCUDAToolkit` module gained support for finding CUDA
+  toolkits when ``nvcc`` is a symbolic link,
+  for example due to a ``ccache`` or ``colornvcc`` wrapper script.
diff --git a/Help/release/dev/export-compile-commands-per-target.rst b/Help/release/dev/export-compile-commands-per-target.rst
new file mode 100644
index 0000000..7063547
--- /dev/null
+++ b/Help/release/dev/export-compile-commands-per-target.rst
@@ -0,0 +1,6 @@
+export-compile-commands-per-target
+----------------------------------
+
+* The :prop_tgt:`EXPORT_COMPILE_COMMANDS` target property was added
+  for the associated :variable:`CMAKE_EXPORT_COMPILE_COMMANDS` variable
+  to allow for configuration of exporting compile commands per target.
diff --git a/Help/release/dev/external-project-configure-handled-by-build.rst b/Help/release/dev/external-project-configure-handled-by-build.rst
new file mode 100644
index 0000000..4a1fac8
--- /dev/null
+++ b/Help/release/dev/external-project-configure-handled-by-build.rst
@@ -0,0 +1,8 @@
+external-project-configure-handled-by-build
+-------------------------------------------
+
+* The :module:`ExternalProject` function ``ExternalProject_Add`` learned a new
+  ``CONFIGURE_HANDLED_BY_BUILD`` option to have subsequent runs of the configure
+  step be triggered by the build step when an external project dependency
+  rebuilds instead of always rerunning the configure step when an external
+  project dependency rebuilds.
diff --git a/Help/release/dev/install-files-rename-genex.rst b/Help/release/dev/install-files-rename-genex.rst
new file mode 100644
index 0000000..f735e24
--- /dev/null
+++ b/Help/release/dev/install-files-rename-genex.rst
@@ -0,0 +1,5 @@
+install-files-rename-genex
+--------------------------
+
+* The :command:`install(FILES)` command ``RENAME`` option learned to
+  support :manual:`generator expressions <cmake-generator-expressions(7)>`.
diff --git a/Help/variable/CMAKE_CUDA_ARCHITECTURES.rst b/Help/variable/CMAKE_CUDA_ARCHITECTURES.rst
index 7f7e679..d885516 100644
--- a/Help/variable/CMAKE_CUDA_ARCHITECTURES.rst
+++ b/Help/variable/CMAKE_CUDA_ARCHITECTURES.rst
@@ -18,3 +18,18 @@
 
 This variable is used to initialize the :prop_tgt:`CUDA_ARCHITECTURES` property
 on all targets. See the target property for additional information.
+
+Examples
+^^^^^^^^
+
+.. code-block:: cmake
+
+  cmake_minimum_required(VERSION)
+
+  if(NOT DEFINED CMAKE_CUDA_ARCHITECTURES)
+    set(CMAKE_CUDA_ARCHITECTURES 75)
+  endif()
+
+  project(example LANGUAGES CUDA)
+
+``CMAKE_CUDA_ARCHITECTURES`` will default to ``75`` unless overridden by the user.
diff --git a/Help/variable/CMAKE_EXPORT_COMPILE_COMMANDS.rst b/Help/variable/CMAKE_EXPORT_COMPILE_COMMANDS.rst
index 724f309..53a19dc 100644
--- a/Help/variable/CMAKE_EXPORT_COMPILE_COMMANDS.rst
+++ b/Help/variable/CMAKE_EXPORT_COMPILE_COMMANDS.rst
@@ -28,7 +28,8 @@
   ]
 
 This is initialized by the :envvar:`CMAKE_EXPORT_COMPILE_COMMANDS` environment
-variable.
+variable, and initializes the :prop_tgt:`EXPORT_COMPILE_COMMANDS` target
+property for all targets.
 
 .. note::
   This option is implemented only by :ref:`Makefile Generators`
diff --git a/Help/variable/MSVC.rst b/Help/variable/MSVC.rst
index ca8775c..a2dbc2e 100644
--- a/Help/variable/MSVC.rst
+++ b/Help/variable/MSVC.rst
@@ -1,8 +1,7 @@
 MSVC
 ----
 
-Set to ``true`` when the compiler is some version of Microsoft Visual
-C++ or another compiler simulating Visual C++.  Any compiler defining
-``_MSC_VER`` is considered simulating Visual C++.
+Set to ``true`` when the compiler is some version of Microsoft Visual C++
+or another compiler simulating the Visual C++ ``cl`` command-line syntax.
 
 See also the :variable:`MSVC_VERSION` variable.
diff --git a/Modules/CMakeCXXCompiler.cmake.in b/Modules/CMakeCXXCompiler.cmake.in
index 92ae2ab..45acfe7 100644
--- a/Modules/CMakeCXXCompiler.cmake.in
+++ b/Modules/CMakeCXXCompiler.cmake.in
@@ -44,7 +44,7 @@
   set(MINGW 1)
 endif()
 set(CMAKE_CXX_COMPILER_ID_RUN 1)
-set(CMAKE_CXX_SOURCE_FILE_EXTENSIONS C;M;c++;cc;cpp;cxx;m;mm;CPP)
+set(CMAKE_CXX_SOURCE_FILE_EXTENSIONS C;M;c++;cc;cpp;cxx;m;mm;mpp;CPP)
 set(CMAKE_CXX_IGNORE_EXTENSIONS inl;h;hpp;HPP;H;o;O;obj;OBJ;def;DEF;rc;RC)
 
 foreach (lang C OBJC OBJCXX)
diff --git a/Modules/CMakeDetermineCCompiler.cmake b/Modules/CMakeDetermineCCompiler.cmake
index ae3abe9..ab33b40 100644
--- a/Modules/CMakeDetermineCCompiler.cmake
+++ b/Modules/CMakeDetermineCCompiler.cmake
@@ -161,9 +161,10 @@
 
   if(CMAKE_C_COMPILER_ID MATCHES "GNU|Clang|QCC")
     get_filename_component(COMPILER_BASENAME "${CMAKE_C_COMPILER}" NAME)
-    if (COMPILER_BASENAME MATCHES "^(.+-)(clang|g?cc)(-[0-9]+(\\.[0-9]+)*)?(-[^.]+)?(\\.exe)?$")
+    if (COMPILER_BASENAME MATCHES "^(.+-)?(clang|g?cc)(-cl)?(-[0-9]+(\\.[0-9]+)*)?(-[^.]+)?(\\.exe)?$")
       set(_CMAKE_TOOLCHAIN_PREFIX ${CMAKE_MATCH_1})
-      set(_CMAKE_COMPILER_SUFFIX ${CMAKE_MATCH_5})
+      set(_CMAKE_TOOLCHAIN_SUFFIX ${CMAKE_MATCH_4})
+      set(_CMAKE_COMPILER_SUFFIX ${CMAKE_MATCH_6})
     elseif(CMAKE_C_COMPILER_ID MATCHES "Clang")
       if(CMAKE_C_COMPILER_TARGET)
         set(_CMAKE_TOOLCHAIN_PREFIX ${CMAKE_C_COMPILER_TARGET}-)
diff --git a/Modules/CMakeDetermineCUDACompiler.cmake b/Modules/CMakeDetermineCUDACompiler.cmake
index 578729c..c77fc3a 100644
--- a/Modules/CMakeDetermineCUDACompiler.cmake
+++ b/Modules/CMakeDetermineCUDACompiler.cmake
@@ -172,7 +172,20 @@
       endif()
     endif()
 
-    get_filename_component(CMAKE_CUDA_COMPILER_TOOLKIT_ROOT "${_CUDA_NVCC_EXECUTABLE}" DIRECTORY)
+    # If NVCC is a symlink due to a wrapper script (e.g. ccache or colornvcc), then invoke it to find the
+    # real non-scattered toolkit.
+    if(IS_SYMLINK ${_CUDA_NVCC_EXECUTABLE})
+      execute_process(COMMAND ${_CUDA_NVCC_EXECUTABLE} "-v" "__cmake_determine_cuda" ERROR_VARIABLE NVCC_ERR)
+      if(NVCC_ERR MATCHES " _HERE_=([^\r\n]*)")
+        set(CMAKE_CUDA_COMPILER_TOOLKIT_ROOT "${CMAKE_MATCH_1}")
+      else()
+        message(FATAL_ERROR "Could not execute nvcc with -v.")
+      endif()
+      unset(NVCC_ERR)
+    else()
+      get_filename_component(CMAKE_CUDA_COMPILER_TOOLKIT_ROOT "${_CUDA_NVCC_EXECUTABLE}" DIRECTORY)
+    endif()
+
     set(CMAKE_CUDA_DEVICE_LINKER "${CMAKE_CUDA_COMPILER_TOOLKIT_ROOT}/nvlink${CMAKE_EXECUTABLE_SUFFIX}")
     set(CMAKE_CUDA_FATBINARY "${CMAKE_CUDA_COMPILER_TOOLKIT_ROOT}/fatbinary${CMAKE_EXECUTABLE_SUFFIX}")
     get_filename_component(CMAKE_CUDA_COMPILER_TOOLKIT_ROOT "${CMAKE_CUDA_COMPILER_TOOLKIT_ROOT}" DIRECTORY)
diff --git a/Modules/CMakeDetermineCXXCompiler.cmake b/Modules/CMakeDetermineCXXCompiler.cmake
index 905eb25..7283bc2 100644
--- a/Modules/CMakeDetermineCXXCompiler.cmake
+++ b/Modules/CMakeDetermineCXXCompiler.cmake
@@ -160,8 +160,9 @@
 
   if("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU|Clang|QCC")
     get_filename_component(COMPILER_BASENAME "${CMAKE_CXX_COMPILER}" NAME)
-    if (COMPILER_BASENAME MATCHES "^(.+-)(clan)?[gc]\\+\\+(-[0-9]+(\\.[0-9]+)*)?(-[^.]+)?(\\.exe)?$")
+    if (COMPILER_BASENAME MATCHES "^(.+-)?(clang\\+\\+|g\\+\\+|clang-cl)(-[0-9]+(\\.[0-9]+)*)?(-[^.]+)?(\\.exe)?$")
       set(_CMAKE_TOOLCHAIN_PREFIX ${CMAKE_MATCH_1})
+      set(_CMAKE_TOOLCHAIN_SUFFIX ${CMAKE_MATCH_3})
       set(_CMAKE_COMPILER_SUFFIX ${CMAKE_MATCH_5})
     elseif("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
       if(CMAKE_CXX_COMPILER_TARGET)
diff --git a/Modules/CMakeFindBinUtils.cmake b/Modules/CMakeFindBinUtils.cmake
index d81fd11..ff178f6 100644
--- a/Modules/CMakeFindBinUtils.cmake
+++ b/Modules/CMakeFindBinUtils.cmake
@@ -70,17 +70,18 @@
    OR (CMAKE_GENERATOR MATCHES "Visual Studio"
        AND NOT CMAKE_VS_PLATFORM_NAME STREQUAL "Tegra-Android"))
 
+  set(_CMAKE_LINKER_NAMES "link")
+  set(_CMAKE_AR_NAMES "lib")
+  set(_CMAKE_MT_NAMES "mt")
   if("x${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_ID}" STREQUAL "xClang")
-    find_program(CMAKE_NM NAMES ${_CMAKE_TOOLCHAIN_PREFIX}nm llvm-nm HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
-    set(_CMAKE_ADDITIONAL_LINKER_NAMES "lld-link")
-    set(_CMAKE_ADDITIONAL_AR_NAMES "llvm-lib")
+    set(_CMAKE_NM_NAMES "llvm-nm" "nm")
+    list(APPEND _CMAKE_AR_NAMES "lib" "llvm-lib")
+    list(APPEND _CMAKE_MT_NAMES "mt" "llvm-mt")
+    list(APPEND _CMAKE_LINKER_NAMES "lld-link")
+    list(APPEND _CMAKE_TOOL_VARS NM)
   endif()
 
-  find_program(CMAKE_LINKER NAMES ${_CMAKE_ADDITIONAL_LINKER_NAMES} link HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
-  find_program(CMAKE_AR     NAMES ${_CMAKE_ADDITIONAL_AR_NAMES}     lib  HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
-  find_program(CMAKE_MT     NAMES mt   HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
-
-  list(APPEND _CMAKE_TOOL_VARS LINKER MT)
+  list(APPEND _CMAKE_TOOL_VARS LINKER MT AR)
 
 # in all other cases search for ar, ranlib, etc.
 else()
@@ -92,55 +93,54 @@
   endif()
 
   if("${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_ID}" STREQUAL Clang)
-    set(_CMAKE_ADDITIONAL_AR_NAMES "llvm-ar")
-    set(_CMAKE_ADDITIONAL_RANLIB_NAMES "llvm-ranlib")
-    set(_CMAKE_ADDITIONAL_STRIP_NAMES "llvm-strip")
     if("x${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_SIMULATE_ID}" STREQUAL "xMSVC")
-      set(_CMAKE_ADDITIONAL_LINKER_NAMES "lld-link")
+      set(_CMAKE_LINKER_NAMES "lld-link")
     else()
-      set(_CMAKE_ADDITIONAL_LINKER_NAMES "ld.lld")
+      set(_CMAKE_LINKER_NAMES "ld.lld")
     endif()
-    set(_CMAKE_ADDITIONAL_NM_NAMES "llvm-nm")
-    set(_CMAKE_ADDITIONAL_OBJDUMP_NAMES "llvm-objdump")
-    set(_CMAKE_ADDITIONAL_OBJCOPY_NAMES "llvm-objcopy")
-    set(_CMAKE_ADDITIONAL_READELF_NAMES "llvm-readelf")
-    set(_CMAKE_ADDITIONAL_DLLTOOL_NAMES "llvm-dlltool")
-    set(_CMAKE_ADDITIONAL_ADDR2LINE_NAMES "llvm-addr2line")
+    list(APPEND _CMAKE_AR_NAMES "llvm-ar")
+    list(APPEND _CMAKE_NM_NAMES "llvm-nm")
+    list(APPEND _CMAKE_OBJDUMP_NAMES "llvm-objdump")
+    list(APPEND _CMAKE_OBJCOPY_NAMES "llvm-objcopy")
+    list(APPEND _CMAKE_READELF_NAMES "llvm-readelf")
+    list(APPEND _CMAKE_DLLTOOL_NAMES "llvm-dlltool")
+    list(APPEND _CMAKE_ADDR2LINE_NAMES "llvm-addr2line")
   endif()
 
-  if(NOT CMAKE_CROSSCOMPILING AND NOT "${_CMAKE_TOOLCHAIN_PREFIX}" STREQUAL "")
-    list(APPEND _CMAKE_ADDITIONAL_AR_NAMES "ar")
-    list(APPEND _CMAKE_ADDITIONAL_RANLIB_NAMES "ranlib")
-    list(APPEND _CMAKE_ADDITIONAL_STRIP_NAMES "strip")
-    list(APPEND _CMAKE_ADDITIONAL_LINKER_NAMES "ld")
-    list(APPEND _CMAKE_ADDITIONAL_NM_NAMES "nm")
-    list(APPEND _CMAKE_ADDITIONAL_OBJDUMP_NAMES "objdump")
-    list(APPEND _CMAKE_ADDITIONAL_OBJCOPY_NAMES "objcopy")
-    list(APPEND _CMAKE_ADDITIONAL_READELF_NAMES "readelf")
-    list(APPEND _CMAKE_ADDITIONAL_DLLTOOL_NAMES "dlltool")
-    list(APPEND _CMAKE_ADDITIONAL_ADDR2LINE_NAMES "addr2line")
-  endif()
+    list(APPEND _CMAKE_AR_NAMES "ar")
+    list(APPEND _CMAKE_RANLIB_NAMES "ranlib")
+    list(APPEND _CMAKE_STRIP_NAMES "strip")
+    list(APPEND _CMAKE_LINKER_NAMES "ld")
+    list(APPEND _CMAKE_NM_NAMES "nm")
+    list(APPEND _CMAKE_OBJDUMP_NAMES "objdump")
+    list(APPEND _CMAKE_OBJCOPY_NAMES "objcopy")
+    list(APPEND _CMAKE_READELF_NAMES "readelf")
+    list(APPEND _CMAKE_DLLTOOL_NAMES "dlltool")
+    list(APPEND _CMAKE_ADDR2LINE_NAMES "addr2line")
 
-  find_program(CMAKE_AR NAMES ${_CMAKE_TOOLCHAIN_PREFIX}ar${_CMAKE_TOOLCHAIN_SUFFIX} ${_CMAKE_ADDITIONAL_AR_NAMES} HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
-
-  find_program(CMAKE_RANLIB NAMES ${_CMAKE_TOOLCHAIN_PREFIX}ranlib ${_CMAKE_ADDITIONAL_RANLIB_NAMES} HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
-  if(NOT CMAKE_RANLIB)
-    set(CMAKE_RANLIB : CACHE INTERNAL "noop for ranlib")
-  endif()
-
-
-  find_program(CMAKE_STRIP NAMES ${_CMAKE_TOOLCHAIN_PREFIX}strip${_CMAKE_TOOLCHAIN_SUFFIX} ${_CMAKE_ADDITIONAL_STRIP_NAMES} HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
-  find_program(CMAKE_LINKER NAMES ${_CMAKE_TOOLCHAIN_PREFIX}ld ${_CMAKE_ADDITIONAL_LINKER_NAMES} HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
-  find_program(CMAKE_NM NAMES ${_CMAKE_TOOLCHAIN_PREFIX}nm ${_CMAKE_ADDITIONAL_NM_NAMES} HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
-  find_program(CMAKE_OBJDUMP NAMES ${_CMAKE_TOOLCHAIN_PREFIX}objdump ${_CMAKE_ADDITIONAL_OBJDUMP_NAMES} HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
-  find_program(CMAKE_OBJCOPY NAMES ${_CMAKE_TOOLCHAIN_PREFIX}objcopy ${_CMAKE_ADDITIONAL_OBJCOPY_NAMES} HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
-  find_program(CMAKE_READELF NAMES ${_CMAKE_TOOLCHAIN_PREFIX}readelf ${_CMAKE_ADDITIONAL_READELF_NAMES} HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
-  find_program(CMAKE_DLLTOOL NAMES ${_CMAKE_TOOLCHAIN_PREFIX}dlltool ${_CMAKE_ADDITIONAL_DLLTOOL_NAMES} HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
-  find_program(CMAKE_ADDR2LINE NAMES ${_CMAKE_TOOLCHAIN_PREFIX}addr2line ${_CMAKE_ADDITIONAL_ADDR2LINE_NAMES} HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
-
-  list(APPEND _CMAKE_TOOL_VARS AR RANLIB STRIP LINKER NM OBJDUMP OBJCOPY READELF DLLTOOL ADDR2LINE)
+    list(APPEND _CMAKE_TOOL_VARS AR RANLIB STRIP LINKER NM OBJDUMP OBJCOPY READELF DLLTOOL ADDR2LINE)
 endif()
 
+foreach(TOOL IN LISTS _CMAKE_TOOL_VARS)
+  foreach(NAME IN LISTS _CMAKE_${TOOL}_NAMES)
+    if(NOT _CMAKE_TOOLCHAIN_PREFIX STREQUAL "")
+      if(NOT _CMAKE_TOOLCHAIN_SUFFIX STREQUAL "")
+        list(PREPEND _CMAKE_${TOOL}_NAMES ${NAME}${_CMAKE_TOOLCHAIN_SUFFIX})
+      endif()
+      list(PREPEND _CMAKE_${TOOL}_NAMES ${_CMAKE_TOOLCHAIN_PREFIX}${NAME})
+    endif()
+    if(NOT _CMAKE_TOOLCHAIN_SUFFIX STREQUAL "")
+      list(PREPEND _CMAKE_${TOOL}_NAMES ${_CMAKE_TOOLCHAIN_PREFIX}${NAME}${_CMAKE_TOOLCHAIN_SUFFIX})
+    endif()
+  endforeach()
+  find_program(CMAKE_${TOOL} NAMES ${_CMAKE_${TOOL}_NAMES} HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
+endforeach()
+
+if(NOT CMAKE_RANLIB)
+    set(CMAKE_RANLIB : CACHE INTERNAL "noop for ranlib")
+endif()
+
+
 if(CMAKE_PLATFORM_HAS_INSTALLNAME)
   find_program(CMAKE_INSTALL_NAME_TOOL NAMES ${_CMAKE_TOOLCHAIN_PREFIX}install_name_tool HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
 
@@ -157,7 +157,7 @@
   if(_CMAKE_TOOL_CACHED)
     mark_as_advanced(CMAKE_${var})
   endif()
-  unset(_CMAKE_ADDITIONAL_${var}_NAMES)
+  unset(_CMAKE_${var}_NAMES)
 endforeach()
 unset(_CMAKE_TOOL_VARS)
 unset(_CMAKE_TOOL_CACHED)
diff --git a/Modules/Compiler/Clang-FindBinUtils.cmake b/Modules/Compiler/Clang-FindBinUtils.cmake
index b852660..e6c469a 100644
--- a/Modules/Compiler/Clang-FindBinUtils.cmake
+++ b/Modules/Compiler/Clang-FindBinUtils.cmake
@@ -2,6 +2,12 @@
   message(FATAL_ERROR "Internal error: _CMAKE_PROCESSING_LANGUAGE is not set")
 endif()
 
+# Ubuntu:
+# * /usr/bin/llvm-ar-9
+# * /usr/bin/llvm-ranlib-9
+string(REGEX MATCH "^([0-9]+)" __version_x
+    "${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_VERSION}")
+
 # Debian:
 # * /usr/bin/llvm-ar-4.0
 # * /usr/bin/llvm-ranlib-4.0
@@ -19,6 +25,7 @@
 # http://manpages.ubuntu.com/manpages/precise/en/man1/llvm-ar.1.html
 find_program(CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_AR NAMES
     "${_CMAKE_TOOLCHAIN_PREFIX}llvm-ar-${__version_x_y}"
+    "${_CMAKE_TOOLCHAIN_PREFIX}llvm-ar-${__version_x}"
     "${_CMAKE_TOOLCHAIN_PREFIX}llvm-ar"
     HINTS ${__clang_hints}
     DOC "LLVM archiver"
@@ -28,6 +35,7 @@
 # http://manpages.ubuntu.com/manpages/precise/en/man1/llvm-ranlib.1.html
 find_program(CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_RANLIB NAMES
     "${_CMAKE_TOOLCHAIN_PREFIX}llvm-ranlib-${__version_x_y}"
+    "${_CMAKE_TOOLCHAIN_PREFIX}llvm-ranlib-${__version_x}"
     "${_CMAKE_TOOLCHAIN_PREFIX}llvm-ranlib"
     HINTS ${__clang_hints}
     DOC "Generate index for LLVM archive"
diff --git a/Modules/ExternalProject.cmake b/Modules/ExternalProject.cmake
index 28d21c1..3307bc6 100644
--- a/Modules/ExternalProject.cmake
+++ b/Modules/ExternalProject.cmake
@@ -543,6 +543,18 @@
         When ``BUILD_IN_SOURCE`` option is enabled, the ``BUILD_COMMAND``
         is used to point to an alternative directory within the source tree.
 
+    ``CONFIGURE_HANDLED_BY_BUILD <bool>``
+      .. versionadded:: 3.20
+
+      Enabling this option relaxes the dependencies of the configure step on
+      other external projects to order-only. This means the configure step will
+      be executed after its external project dependencies are built but it will
+      not be marked dirty when one of its external project dependencies is
+      rebuilt. This option can be enabled when the build step is smart enough
+      to figure out if the configure step needs to be rerun. CMake and Meson are
+      examples of build systems whose build step is smart enough to know if the
+      configure step needs to be rerun.
+
   **Build Step Options:**
     If the configure step assumed the external project uses CMake as its build
     system, the build step will also. Otherwise, the build step will assume a
@@ -3083,6 +3095,23 @@
   )
 endfunction()
 
+function(_ep_get_file_deps var name)
+  set(file_deps)
+
+  get_property(deps TARGET ${name} PROPERTY _EP_DEPENDS)
+  foreach(dep IN LISTS deps)
+    get_property(dep_type TARGET ${dep} PROPERTY TYPE)
+    if(dep_type STREQUAL "UTILITY")
+      get_property(is_ep TARGET ${dep} PROPERTY _EP_IS_EXTERNAL_PROJECT)
+      if(is_ep)
+        _ep_get_step_stampfile(${dep} "done" done_stamp_file)
+        list(APPEND file_deps ${done_stamp_file})
+      endif()
+    endif()
+  endforeach()
+
+  set("${var}" "${file_deps}" PARENT_SCOPE)
+endfunction()
 
 function(_ep_extract_configure_command var name)
   get_property(cmd_set TARGET ${name} PROPERTY _EP_CONFIGURE_COMMAND SET)
@@ -3191,19 +3220,13 @@
 function(_ep_add_configure_command name)
   ExternalProject_Get_Property(${name} binary_dir tmp_dir)
 
-  # Depend on other external projects (file-level).
   set(file_deps)
-  get_property(deps TARGET ${name} PROPERTY _EP_DEPENDS)
-  foreach(dep IN LISTS deps)
-    get_property(dep_type TARGET ${dep} PROPERTY TYPE)
-    if(dep_type STREQUAL "UTILITY")
-      get_property(is_ep TARGET ${dep} PROPERTY _EP_IS_EXTERNAL_PROJECT)
-      if(is_ep)
-        _ep_get_step_stampfile(${dep} "done" done_stamp_file)
-        list(APPEND file_deps ${done_stamp_file})
-      endif()
-    endif()
-  endforeach()
+  get_property(configure_handled_by_build TARGET ${name}
+               PROPERTY _EP_CONFIGURE_HANDLED_BY_BUILD)
+  if(NOT configure_handled_by_build)
+    # Depend on other external projects (file-level)
+    _ep_get_file_deps(file_deps ${name})
+  endif()
 
   _ep_extract_configure_command(cmd ${name})
 
@@ -3254,6 +3277,14 @@
 function(_ep_add_build_command name)
   ExternalProject_Get_Property(${name} binary_dir)
 
+  set(file_deps)
+  get_property(configure_handled_by_build TARGET ${name}
+               PROPERTY _EP_CONFIGURE_HANDLED_BY_BUILD)
+  if(configure_handled_by_build)
+    # Depend on other external projects (file-level)
+    _ep_get_file_deps(file_deps ${name})
+  endif()
+
   get_property(cmd_set TARGET ${name} PROPERTY _EP_BUILD_COMMAND SET)
   if(cmd_set)
     get_property(cmd TARGET ${name} PROPERTY _EP_BUILD_COMMAND)
@@ -3296,6 +3327,7 @@
       BYPRODUCTS \${build_byproducts}
       WORKING_DIRECTORY \${binary_dir}
       DEPENDEES configure
+      DEPENDS \${file_deps}
       ALWAYS \${always}
       ${log}
       ${uses_terminal}
diff --git a/Modules/FindCUDA.cmake b/Modules/FindCUDA.cmake
index 6daf81d..240f0a5 100644
--- a/Modules/FindCUDA.cmake
+++ b/Modules/FindCUDA.cmake
@@ -834,7 +834,20 @@
     )
 
   if (CUDA_TOOLKIT_ROOT_DIR_NVCC)
-    get_filename_component(CUDA_TOOLKIT_ROOT_DIR_NVCC_PAR "${CUDA_TOOLKIT_ROOT_DIR_NVCC}" DIRECTORY)
+    # If NVCC is a symlink due to a wrapper script (e.g. ccache or colornvcc), then invoke it to find the
+    # real non-scattered toolkit.
+    if(IS_SYMLINK ${CUDA_TOOLKIT_ROOT_DIR_NVCC})
+      execute_process(COMMAND ${CUDA_TOOLKIT_ROOT_DIR_NVCC} "-v" "__cmake_determine_cuda" ERROR_VARIABLE NVCC_ERR)
+      if(NVCC_ERR MATCHES " _HERE_=([^\r\n]*)")
+        set(CUDA_TOOLKIT_ROOT_DIR_NVCC_PAR "${CMAKE_MATCH_1}")
+      else()
+        message(FATAL_ERROR "Could not execute nvcc with -v.")
+      endif()
+      unset(NVCC_ERR)
+    else()
+      get_filename_component(CUDA_TOOLKIT_ROOT_DIR_NVCC_PAR "${CUDA_TOOLKIT_ROOT_DIR_NVCC}" DIRECTORY)
+    endif()
+
     get_filename_component(CUDA_TOOLKIT_ROOT_DIR "${CUDA_TOOLKIT_ROOT_DIR_NVCC_PAR}" DIRECTORY CACHE)
     string(REGEX REPLACE "[/\\\\]?bin[64]*[/\\\\]?$" "" CUDA_TOOLKIT_ROOT_DIR ${CUDA_TOOLKIT_ROOT_DIR})
     # We need to force this back into the cache.
diff --git a/Modules/FindCUDAToolkit.cmake b/Modules/FindCUDAToolkit.cmake
index 61e264b..0d80c80 100644
--- a/Modules/FindCUDAToolkit.cmake
+++ b/Modules/FindCUDAToolkit.cmake
@@ -519,7 +519,19 @@
       endif()
 
       if(CUDAToolkit_NVCC_EXECUTABLE)
-        get_filename_component(CUDAToolkit_BIN_DIR "${CUDAToolkit_NVCC_EXECUTABLE}" DIRECTORY)
+        # If NVCC is a symlink due to a wrapper script (e.g. ccache or colornvcc), then invoke it to find the
+        # real non-scattered toolkit.
+        if(IS_SYMLINK ${CUDAToolkit_NVCC_EXECUTABLE})
+          execute_process(COMMAND ${CUDAToolkit_NVCC_EXECUTABLE} "-v" "__cmake_determine_cuda" ERROR_VARIABLE NVCC_ERR)
+          if(NVCC_ERR MATCHES " _HERE_=([^\r\n]*)")
+            set(CUDAToolkit_BIN_DIR "${CMAKE_MATCH_1}")
+          else()
+            message(FATAL_ERROR "Could not execute nvcc with -v.")
+          endif()
+          unset(NVCC_ERR)
+        else()
+          get_filename_component(CUDAToolkit_BIN_DIR "${CUDAToolkit_NVCC_EXECUTABLE}" DIRECTORY)
+        endif()
 
         set(CUDAToolkit_BIN_DIR "${CUDAToolkit_BIN_DIR}" CACHE PATH "" FORCE)
         mark_as_advanced(CUDAToolkit_BIN_DIR)
diff --git a/Modules/FindHDF5.cmake b/Modules/FindHDF5.cmake
index 12f4c17..f64f72f 100644
--- a/Modules/FindHDF5.cmake
+++ b/Modules/FindHDF5.cmake
@@ -116,15 +116,22 @@
 
 With all components enabled, the following targets will be defined:
 
-::
-
-  ``hdf5::hdf5``
-  ``hdf5::hdf5_hl_cpp``
-  ``hdf5::hdf5_fortran``
-  ``hdf5::hdf5_hl``
-  ``hdf5::hdf5_hl_cpp``
-  ``hdf5::hdf5_hl_fortran``
-  ``hdf5::h5diff``
+``HDF5::HDF5``
+  All detected ``HDF5_LIBRARIES``.
+``hdf5::hdf5``
+  C library.
+``hdf5::hdf5_cpp``
+  C++ library.
+``hdf5::hdf5_fortran``
+  Fortran library.
+``hdf5::hdf5_hl``
+  High-level C library.
+``hdf5::hdf5_hl_cpp``
+  High-level C++ library.
+``hdf5::hdf5_hl_fortran``
+  High-level Fortran library.
+``hdf5::h5diff``
+  ``h5diff`` executable.
 
 Hints
 ^^^^^
@@ -1001,10 +1008,10 @@
     add_library(HDF5::HDF5 INTERFACE IMPORTED)
     string(REPLACE "-D" "" _hdf5_definitions "${HDF5_DEFINITIONS}")
     set_target_properties(HDF5::HDF5 PROPERTIES
-      INTERFACE_LINK_LIBRARIES "${HDF5_LIBRARIES}"
       INTERFACE_INCLUDE_DIRECTORIES "${HDF5_INCLUDE_DIRS}"
       INTERFACE_COMPILE_DEFINITIONS "${_hdf5_definitions}")
     unset(_hdf5_definitions)
+    target_link_libraries(HDF5::HDF5 INTERFACE ${HDF5_LIBRARIES})
   endif ()
 
   foreach (hdf5_lang IN LISTS HDF5_LANGUAGE_BINDINGS)
@@ -1147,6 +1154,21 @@
     message(STATUS "HDF5_${_lang}_HL_LIBRARY: ${HDF5_${_lang}_HL_LIBRARY}")
     message(STATUS "HDF5_${_lang}_HL_LIBRARIES: ${HDF5_${_lang}_HL_LIBRARIES}")
   endforeach()
+  message(STATUS "Defined targets (if any):")
+  foreach(_lang IN  ITEMS "" "_cpp" "_fortran")
+    foreach(_hl IN  ITEMS "" "_hl")
+      foreach(_prefix IN ITEMS "hdf5::" "")
+        foreach(_suffix IN ITEMS "-static" "-shared" "")
+          set (_target ${_prefix}hdf5${_hl}${_lang}${_suffix})
+          if (TARGET  ${_target})
+            message(STATUS "... ${_target}")
+          else()
+            #message(STATUS "... ${_target} does not exist")
+          endif()
+        endforeach()
+      endforeach()
+    endforeach()
+  endforeach()
 endif()
 unset(_lang)
 unset(_HDF5_NEED_TO_SEARCH)
diff --git a/Modules/FindJPEG.cmake b/Modules/FindJPEG.cmake
index 3f243de..add2486 100644
--- a/Modules/FindJPEG.cmake
+++ b/Modules/FindJPEG.cmake
@@ -58,7 +58,7 @@
 
 find_path(JPEG_INCLUDE_DIR jpeglib.h)
 
-set(jpeg_names ${JPEG_NAMES} jpeg jpeg-static libjpeg libjpeg-static)
+set(jpeg_names ${JPEG_NAMES} jpeg jpeg-static libjpeg libjpeg-static turbojpeg turbojpeg-static)
 foreach(name ${jpeg_names})
   list(APPEND jpeg_names_debug "${name}d")
 endforeach()
diff --git a/Modules/FindMPI.cmake b/Modules/FindMPI.cmake
index 19e6e57..8476823 100644
--- a/Modules/FindMPI.cmake
+++ b/Modules/FindMPI.cmake
@@ -653,6 +653,7 @@
   foreach(_MPI_INCLUDE_PATH IN LISTS MPI_ALL_INCLUDE_PATHS)
     string(REGEX REPLACE "^ ?${_MPI_PREPROCESSOR_FLAG_REGEX}${CMAKE_INCLUDE_FLAG_${LANG}} *" "" _MPI_INCLUDE_PATH "${_MPI_INCLUDE_PATH}")
     string(REPLACE "\"" "" _MPI_INCLUDE_PATH "${_MPI_INCLUDE_PATH}")
+    string(REPLACE "'" "" _MPI_INCLUDE_PATH "${_MPI_INCLUDE_PATH}")
     get_filename_component(_MPI_INCLUDE_PATH "${_MPI_INCLUDE_PATH}" REALPATH)
     list(APPEND MPI_INCLUDE_DIRS_WORK "${_MPI_INCLUDE_PATH}")
   endforeach()
diff --git a/Modules/FindPostgreSQL.cmake b/Modules/FindPostgreSQL.cmake
index cd50d8c..911210f 100644
--- a/Modules/FindPostgreSQL.cmake
+++ b/Modules/FindPostgreSQL.cmake
@@ -247,7 +247,7 @@
 # Did we find anything?
 include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake)
 find_package_handle_standard_args(PostgreSQL
-                                  REQUIRED_VARS PostgreSQL_LIBRARY PostgreSQL_INCLUDE_DIR PostgreSQL_TYPE_INCLUDE_DIR
+                                  REQUIRED_VARS PostgreSQL_LIBRARY PostgreSQL_INCLUDE_DIR
                                   VERSION_VAR PostgreSQL_VERSION_STRING)
 set(PostgreSQL_FOUND  ${POSTGRESQL_FOUND})
 
@@ -271,16 +271,19 @@
 
 # Now try to get the include and library path.
 if(PostgreSQL_FOUND)
+  set(PostgreSQL_INCLUDE_DIRS ${PostgreSQL_INCLUDE_DIR})
+  if(PostgreSQL_TYPE_INCLUDE_DIR)
+    list(APPEND PostgreSQL_INCLUDE_DIRS ${PostgreSQL_TYPE_INCLUDE_DIR})
+  endif()
+  set(PostgreSQL_LIBRARY_DIRS ${PostgreSQL_LIBRARY_DIR} )
   if (NOT TARGET PostgreSQL::PostgreSQL)
     add_library(PostgreSQL::PostgreSQL UNKNOWN IMPORTED)
     set_target_properties(PostgreSQL::PostgreSQL PROPERTIES
-      INTERFACE_INCLUDE_DIRECTORIES "${PostgreSQL_INCLUDE_DIR};${PostgreSQL_TYPE_INCLUDE_DIR}")
+      INTERFACE_INCLUDE_DIRECTORIES "${PostgreSQL_INCLUDE_DIRS}")
     __postgresql_import_library(PostgreSQL::PostgreSQL PostgreSQL_LIBRARY "")
     __postgresql_import_library(PostgreSQL::PostgreSQL PostgreSQL_LIBRARY "RELEASE")
     __postgresql_import_library(PostgreSQL::PostgreSQL PostgreSQL_LIBRARY "DEBUG")
   endif ()
-  set(PostgreSQL_INCLUDE_DIRS ${PostgreSQL_INCLUDE_DIR} ${PostgreSQL_TYPE_INCLUDE_DIR} )
-  set(PostgreSQL_LIBRARY_DIRS ${PostgreSQL_LIBRARY_DIR} )
 endif()
 
 mark_as_advanced(PostgreSQL_INCLUDE_DIR PostgreSQL_TYPE_INCLUDE_DIR)
diff --git a/Modules/UseJava.cmake b/Modules/UseJava.cmake
index a5f8a08..120a54c 100644
--- a/Modules/UseJava.cmake
+++ b/Modules/UseJava.cmake
@@ -23,7 +23,8 @@
           [VERSION <version>]
           [OUTPUT_NAME <name>]
           [OUTPUT_DIR <dir>]
-          [GENERATE_NATIVE_HEADERS <target> [DESTINATION <dir>]]
+          [GENERATE_NATIVE_HEADERS <target>
+                             [DESTINATION (<dir>|INSTALL <dir> [BUILD <dir>])]]
           )
 
 This command creates a ``<target_name>.jar``.  It compiles the given
@@ -37,7 +38,7 @@
 they have been since the first version of this module).
 
 .. versionadded:: 3.4
-  Support fot response files (prefixed by ``@``) in the ``SOURCES`` list.
+  Support for response files (prefixed by ``@``) in the ``SOURCES`` list.
 
 The default ``OUTPUT_DIR`` can also be changed by setting the variable
 ``CMAKE_JAVA_TARGET_OUTPUT_DIR``.
@@ -52,6 +53,12 @@
 
   ``GENERATE_NATIVE_HEADERS`` option requires, at least, version 1.8 of the JDK.
 
+.. versionadded:: 3.20
+  ``DESTINATION`` sub-option now supports the possibility to specify different
+  output directories for ``BUILD`` and ``INSTALL`` steps. This is required to
+  export the interface target generated by ``GENERATE_NATIVE_HEADERS`` option.
+  If ``BUILD`` directory is not specified, a default directory will be used.
+
 The ``add_jar()`` function sets the following target properties on
 ``<target_name>``:
 
@@ -66,6 +73,11 @@
   The directory where the class files can be found.  For example to use them
   with ``javah``.
 
+.. versionadded:: 3.20
+  The target generated by option ``GENERATE_NATIVE_HEADERS`` has the property
+  ``NATIVE_HEADERS_DIRECTORY`` which specify the directory holding the native
+  headers.
+
 .. code-block:: cmake
 
  install_jar(<target_name> <destination>)
@@ -217,6 +229,18 @@
   add_library(bar bar.cpp)
   target_link_libraries(bar PRIVATE foo-native)
 
+.. versionadded:: 3.20
+  It is now possible to export the target generated by
+  ``GENERATE_NATIVE_HEADERS`` option.
+
+  .. code-block:: cmake
+
+    add_jar(foo foo.java GENERATE_NATIVE_HEADERS foo-native
+                                                 DESTINATION INSTALL include)
+    install(TARGETS foo-native EXPORT native)
+    install(DIRECTORY "$<TARGET_PROPERTY:foo-native,NATIVE_HEADERS_DIRECTORY>/"
+            DESTINATION include)
+    install(EXPORT native DESTINATION /to/export NAMESPACE foo)
 
 Finding JARs
 ^^^^^^^^^^^^
@@ -493,7 +517,10 @@
       if (Java_VERSION VERSION_LESS 1.8)
         message (FATAL_ERROR "ADD_JAR: GENERATE_NATIVE_HEADERS is not supported with this version of Java.")
       endif()
-      cmake_parse_arguments (_add_jar_GENERATE_NATIVE_HEADERS "" "DESTINATION" "" ${_add_jar_GENERATE_NATIVE_HEADERS})
+
+      unset (_GENERATE_NATIVE_HEADERS_OUTPUT_DESC)
+
+      cmake_parse_arguments (_add_jar_GENERATE_NATIVE_HEADERS "" "" "DESTINATION" ${_add_jar_GENERATE_NATIVE_HEADERS})
       if (NOT _add_jar_GENERATE_NATIVE_HEADERS_UNPARSED_ARGUMENTS)
         message (FATAL_ERROR "ADD_JAR: GENERATE_NATIVE_HEADERS: missing required argument.")
       endif()
@@ -504,11 +531,30 @@
       endif()
       if (NOT _add_jar_GENERATE_NATIVE_HEADERS_DESTINATION)
         set (_add_jar_GENERATE_NATIVE_HEADERS_DESTINATION "${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/${_TARGET_NAME}.dir/native_headers")
+      else()
+        list (LENGTH _add_jar_GENERATE_NATIVE_HEADERS_DESTINATION length)
+        if (NOT length EQUAL 1)
+          cmake_parse_arguments (_add_jar_GENERATE_NATIVE_HEADERS_DESTINATION "" "BUILD;INSTALL" "" "${_add_jar_GENERATE_NATIVE_HEADERS_DESTINATION}")
+          if (_add_jar_GENERATE_NATIVE_HEADERS_DESTINATION_UNPARSED_ARGUMENTS)
+            message (FATAL_ERROR "ADD_JAR: GENERATE_NATIVE_HEADERS: DESTINATION: ${_add_jar_GENERATE_NATIVE_HEADERS_DESTINATION_UNPARSED_ARGUMENTS}: unexpected argument(s).")
+          endif()
+          if (NOT _add_jar_GENERATE_NATIVE_HEADERS_DESTINATION_INSTALL)
+            message (FATAL_ERROR "ADD_JAR: GENERATE_NATIVE_HEADERS: DESTINATION: INSTALL sub-option is required.")
+          endif()
+          if (NOT _add_jar_GENERATE_NATIVE_HEADERS_DESTINATION_BUILD)
+            set(_add_jar_GENERATE_NATIVE_HEADERS_DESTINATION_BUILD "${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/${_TARGET_NAME}.dir/native_headers")
+          endif()
+          set(_add_jar_GENERATE_NATIVE_HEADERS_DESTINATION "${_add_jar_GENERATE_NATIVE_HEADERS_DESTINATION_BUILD}")
+          set(_GENERATE_NATIVE_HEADERS_OUTPUT_DESC "$<BUILD_INTERFACE:${_add_jar_GENERATE_NATIVE_HEADERS_DESTINATION_BUILD}>" "$<INSTALL_INTERFACE:${_add_jar_GENERATE_NATIVE_HEADERS_DESTINATION_INSTALL}>")
+        endif()
       endif()
 
       set (_GENERATE_NATIVE_HEADERS_TARGET ${_add_jar_GENERATE_NATIVE_HEADERS_UNPARSED_ARGUMENTS})
       set (_GENERATE_NATIVE_HEADERS_OUTPUT_DIR "${_add_jar_GENERATE_NATIVE_HEADERS_DESTINATION}")
       set (_GENERATE_NATIVE_HEADERS -h "${_GENERATE_NATIVE_HEADERS_OUTPUT_DIR}")
+      if(NOT _GENERATE_NATIVE_HEADERS_OUTPUT_DESC)
+        set(_GENERATE_NATIVE_HEADERS_OUTPUT_DESC "${_GENERATE_NATIVE_HEADERS_OUTPUT_DIR}")
+      endif()
     endif()
 
     if (LIBRARY_OUTPUT_PATH)
@@ -762,8 +808,9 @@
     # create an INTERFACE library encapsulating include directory for generated headers
     add_library (${_GENERATE_NATIVE_HEADERS_TARGET} INTERFACE)
     target_include_directories (${_GENERATE_NATIVE_HEADERS_TARGET} INTERFACE
-      "${_GENERATE_NATIVE_HEADERS_OUTPUT_DIR}"
+      "${_GENERATE_NATIVE_HEADERS_OUTPUT_DESC}"
       ${JNI_INCLUDE_DIRS})
+    set_property(TARGET ${_GENERATE_NATIVE_HEADERS_TARGET} PROPERTY NATIVE_HEADERS_DIRECTORY "${_GENERATE_NATIVE_HEADERS_OUTPUT_DIR}")
     # this INTERFACE library depends on jar generation
     add_dependencies (${_GENERATE_NATIVE_HEADERS_TARGET} ${_TARGET_NAME})
 
diff --git a/Source/CMakeVersion.cmake b/Source/CMakeVersion.cmake
index 29929a2..f60b098 100644
--- a/Source/CMakeVersion.cmake
+++ b/Source/CMakeVersion.cmake
@@ -1,7 +1,7 @@
 # CMake version number components.
 set(CMake_VERSION_MAJOR 3)
 set(CMake_VERSION_MINOR 19)
-set(CMake_VERSION_PATCH 20210105)
+set(CMake_VERSION_PATCH 20210114)
 #set(CMake_VERSION_RC 0)
 set(CMake_VERSION_IS_DIRTY 0)
 
diff --git a/Source/CPack/IFW/cmCPackIFWInstaller.cxx b/Source/CPack/IFW/cmCPackIFWInstaller.cxx
index 8e00ad6..359fc56 100644
--- a/Source/CPack/IFW/cmCPackIFWInstaller.cxx
+++ b/Source/CPack/IFW/cmCPackIFWInstaller.cxx
@@ -66,7 +66,7 @@
         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 @@
         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 @@
   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 @@
 
   xout.StartDocument();
 
-  WriteGeneratedByToStrim(xout);
+  this->WriteGeneratedByToStrim(xout);
 
   xout.StartElement("Installer");
 
@@ -535,7 +535,7 @@
       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 56a74c5..c4bd7f1 100644
--- a/Source/CPack/IFW/cmCPackIFWPackage.cxx
+++ b/Source/CPack/IFW/cmCPackIFWPackage.cxx
@@ -337,7 +337,7 @@
 
   group.Name = groupName;
 
-  if (Generator) {
+  if (this->Generator) {
     this->Name = this->Generator->GetGroupPackageName(&group);
   } else {
     this->Name = group.Name;
@@ -530,7 +530,7 @@
 
   xout.StartDocument();
 
-  WriteGeneratedByToStrim(xout);
+  this->WriteGeneratedByToStrim(xout);
 
   xout.StartElement("Package");
 
@@ -577,7 +577,7 @@
   }
 
   // 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 @@
   }
 
   // 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 dbd5540..0cc6f2f 100644
--- a/Source/CPack/IFW/cmCPackIFWPackage.h
+++ b/Source/CPack/IFW/cmCPackIFWPackage.h
@@ -53,7 +53,7 @@
 
     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 f5e8744..1287907 100644
--- a/Source/CPack/IFW/cmCPackIFWRepository.cxx
+++ b/Source/CPack/IFW/cmCPackIFWRepository.cxx
@@ -46,9 +46,9 @@
   // 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 @@
   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 967cc60..5348f86 100644
--- a/Source/CPack/cmCPackArchiveGenerator.cxx
+++ b/Source/CPack/cmCPackArchiveGenerator.cxx
@@ -80,10 +80,10 @@
     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::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 @@
       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 @@
         // 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 @@
             << 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 @@
         {
           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 @@
   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 @@
       {
         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::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 @@
   // 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::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 @@
   // 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 d40e5fc..4305c7e 100644
--- a/Source/CPack/cmCPackComponentGroup.cxx
+++ b/Source/CPack/cmCPackComponentGroup.cxx
@@ -25,6 +25,6 @@
 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 6f21d87..43dbdb5 100644
--- a/Source/CPack/cmCPackDebGenerator.cxx
+++ b/Source/CPack/cmCPackDebGenerator.cxx
@@ -96,20 +96,20 @@
   }
 
   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 @@
 
 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::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 @@
 
 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 @@
                     << 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 @@
   // 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 @@
       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 @@
 
 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 @@
 
 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 @@
     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 @@
   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 @@
   }
 
   // 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 @@
     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 @@
   // 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 @@
     // 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 @@
   // 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 @@
 
   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 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 @@
                       << 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 @@
                       << 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 @@
     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 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 @@
       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 @@
             << "> 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 @@
   // 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 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 @@
 
   // 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 @@
                     << 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 @@
   }
 
   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 @@
     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 @@
   }
 
   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 @@
     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 @@
 
 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 0bc8456..e3521a0 100644
--- a/Source/CPack/cmCPackExternalGenerator.cxx
+++ b/Source/CPack/cmCPackExternalGenerator.cxx
@@ -95,7 +95,7 @@
   bool setDestDir, const std::string& tempInstallDirectory)
 {
   if (this->StagingEnabled()) {
-    return cmCPackGenerator::InstallProjectViaInstallCommands(
+    return this->cmCPackGenerator::InstallProjectViaInstallCommands(
       setDestDir, tempInstallDirectory);
   }
 
@@ -106,7 +106,7 @@
   bool setDestDir, const std::string& tempInstallDirectory)
 {
   if (this->StagingEnabled()) {
-    return cmCPackGenerator::InstallProjectViaInstallScript(
+    return this->cmCPackGenerator::InstallProjectViaInstallScript(
       setDestDir, tempInstallDirectory);
   }
 
@@ -118,7 +118,7 @@
   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 @@
   cmGlobalGenerator* globalGenerator, const std::string& buildConfig)
 {
   if (this->StagingEnabled()) {
-    return cmCPackGenerator::RunPreinstallTarget(
+    return this->cmCPackGenerator::RunPreinstallTarget(
       installProjectName, installDirectory, globalGenerator, buildConfig);
   }
 
@@ -145,7 +145,7 @@
   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 8b544b4..3db4162 100644
--- a/Source/CPack/cmCPackGenerator.cxx
+++ b/Source/CPack/cmCPackGenerator.cxx
@@ -60,18 +60,18 @@
   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 @@
                         << 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 @@
     //  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 @@
   // 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 @@
       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 @@
     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 @@
   }
 
   // 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 @@
    *    (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::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 @@
   // 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 @@
   // 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 @@
   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 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 @@
     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::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 @@
 
     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 @@
     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 @@
     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 2109b4e..435f0ec 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 @@
   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 @@
                 "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 @@
     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 @@
   }
 
   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 @@
   // 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 @@
     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 @@
     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 60faecd..98dc890 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 @@
 
   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 @@
   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 0c1cecf..c3f6d59 100644
--- a/Source/CPack/cmCPackRPMGenerator.cxx
+++ b/Source/CPack/cmCPackRPMGenerator.cxx
@@ -51,11 +51,11 @@
   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 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 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 @@
         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 @@
               << 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 @@
         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 @@
           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 @@
         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 @@
               << 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 @@
       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 @@
   }
 
   if (retval) {
-    AddGeneratedPackageNames();
+    this->AddGeneratedPackageNames();
   }
 
   return retval;
@@ -340,7 +341,7 @@
   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 @@
 
   // 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 @@
   }
 
   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::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 a4a5e6f..3e36e8c 100644
--- a/Source/CPack/cmCPackSTGZGenerator.cxx
+++ b/Source/CPack/cmCPackSTGZGenerator.cxx
@@ -50,7 +50,7 @@
    * 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 c533cd7..a353435 100644
--- a/Source/CTest/cmCTestBZR.cxx
+++ b/Source/CTest/cmCTestBZR.cxx
@@ -104,8 +104,8 @@
   {
     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 @@
 
   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 4151fde..88e2871 100644
--- a/Source/CTest/cmCTestBuildCommand.cxx
+++ b/Source/CTest/cmCTestBuildCommand.cxx
@@ -137,7 +137,7 @@
 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 093b2d1..5fb52bf 100644
--- a/Source/CTest/cmCTestCoverageHandler.cxx
+++ b/Source/CTest/cmCTestCoverageHandler.cxx
@@ -778,16 +778,16 @@
   {
     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 6ec7d0e..f89fc9b 100644
--- a/Source/CTest/cmCTestLaunchReporter.cxx
+++ b/Source/CTest/cmCTestLaunchReporter.cxx
@@ -284,7 +284,7 @@
 
   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 a08cb34..9793c5b 100644
--- a/Source/CTest/cmCTestMultiProcessHandler.cxx
+++ b/Source/CTest/cmCTestMultiProcessHandler.cxx
@@ -56,8 +56,8 @@
   // 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 @@
   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 @@
       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 @@
 
     if (processors <= minProcessorsRequired) {
       minProcessorsRequired = processors;
-      testWithMinProcessors = GetName(test);
+      testWithMinProcessors = this->GetName(test);
     }
 
     if (testLoadOk && processors <= numToStart && this->StartTest(test)) {
@@ -660,7 +660,7 @@
   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 @@
 void cmCTestMultiProcessHandler::CreateTestCostList()
 {
   if (this->ParallelLevel > 1) {
-    CreateParallelTestCostList();
+    this->CreateParallelTestCostList();
   } else {
-    CreateSerialTestCostList();
+    this->CreateSerialTestCostList();
   }
 }
 
@@ -862,7 +862,7 @@
 {
   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 @@
     }
 
     TestList dependencies;
-    GetAllTestDependencies(test, dependencies);
+    this->GetAllTestDependencies(test, dependencies);
 
     for (int testDependency : dependencies) {
       if (!cm::contains(alreadySortedTests, testDependency)) {
@@ -1274,7 +1274,7 @@
 void cmCTestMultiProcessHandler::PrintTestList()
 {
   if (this->CTest->GetOutputAsJson()) {
-    PrintOutputAsJson();
+    this->PrintOutputAsJson();
     return;
   }
 
diff --git a/Source/CTest/cmCTestP4.cxx b/Source/CTest/cmCTestP4.cxx
index 1375be4..50c9c16 100644
--- a/Source/CTest/cmCTestP4.cxx
+++ b/Source/CTest/cmCTestP4.cxx
@@ -56,7 +56,7 @@
   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 @@
   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 @@
   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 @@
       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 @@
     : P4(p4)
     , AlreadyNotified(false)
   {
-    this->SetLog(&P4->Log, prefix);
+    this->SetLog(&this->P4->Log, prefix);
     this->RegexDiff.compile("^==== (.*)#[0-9]+ - (.*)");
   }
 
@@ -134,12 +134,12 @@
   {
     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 @@
 
 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 @@
 
     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 @@
     , 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 @@
       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 @@
         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 @@
 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 @@
   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::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 @@
   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::LoadModifications()
 {
   std::vector<char const*> p4_diff;
-  SetP4Options(p4_diff);
+  this->SetP4Options(p4_diff);
 
   p4_diff.push_back("diff");
 
@@ -491,7 +491,7 @@
   }
 
   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 4d65c9b..5a6c775 100644
--- a/Source/CTest/cmCTestRunTest.cxx
+++ b/Source/CTest/cmCTestRunTest.cxx
@@ -139,7 +139,7 @@
         s << "SKIP_RETURN_CODE=" << this->TestProperties->SkipReturnCode;
       }
       this->TestResult.CompletionStatus = s.str();
-      cmCTestLog(this->CTest, HANDLER_OUTPUT, "***Skipped ");
+      outputStream << "***Skipped ";
       skipped = true;
     } else if (success != this->TestProperties->WillFail) {
       this->TestResult.Status = cmCTestTestHandler::COMPLETED;
@@ -195,10 +195,11 @@
   sprintf(buf, "%6.2f sec", this->TestProcess->GetTotalTime().count());
   outputStream << buf << "\n";
 
+  bool passedOrSkipped = passed || skipped;
   if (this->CTest->GetTestProgressOutput()) {
-    if (!passed) {
+    if (!passedOrSkipped) {
       // 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,12 +212,12 @@
       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);
     }
   }
-  if (!this->CTest->GetTestProgressOutput() || !passed) {
+  if (!this->CTest->GetTestProgressOutput() || !passedOrSkipped) {
     cmCTestLog(this->CTest, HANDLER_OUTPUT, outputStream.str());
   }
 
@@ -485,8 +486,8 @@
                  << 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 44dfab2..4692dbd 100644
--- a/Source/CTest/cmCTestSVN.cxx
+++ b/Source/CTest/cmCTestSVN.cxx
@@ -286,9 +286,9 @@
   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 @@
     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 @@
       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 84bb791..a8c9df6 100644
--- a/Source/CTest/cmCTestTestHandler.cxx
+++ b/Source/CTest/cmCTestTestHandler.cxx
@@ -340,7 +340,7 @@
   this->ExcludeFixtureSetupRegExp.clear();
   this->ExcludeFixtureCleanupRegExp.clear();
 
-  TestsToRunString.clear();
+  this->TestsToRunString.clear();
   this->UseUnion = false;
   this->TestList.clear();
 }
@@ -877,7 +877,7 @@
     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 @@
     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 409025f..3a6651f 100644
--- a/Source/CTest/cmParseBlanketJSCoverage.cxx
+++ b/Source/CTest/cmParseBlanketJSCoverage.cxx
@@ -66,7 +66,7 @@
         }
         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 @@
          *  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 711a856..9311769 100644
--- a/Source/CTest/cmParseCoberturaCoverage.cxx
+++ b/Source/CTest/cmParseCoberturaCoverage.cxx
@@ -66,7 +66,7 @@
 
           // 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 @@
           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 016e90c..640873e 100644
--- a/Source/CTest/cmParseDelphiCoverage.cxx
+++ b/Source/CTest/cmParseDelphiCoverage.cxx
@@ -133,7 +133,7 @@
     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 9ee1c17..c7cbd34 100644
--- a/Source/CTest/cmProcess.cxx
+++ b/Source/CTest/cmProcess.cxx
@@ -177,7 +177,7 @@
 
       // 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/QtDialog/CMakeLists.txt b/Source/QtDialog/CMakeLists.txt
index 452a303..0c263bb 100644
--- a/Source/QtDialog/CMakeLists.txt
+++ b/Source/QtDialog/CMakeLists.txt
@@ -3,20 +3,52 @@
 
 project(QtDialog)
 CMake_OPTIONAL_COMPONENT(cmake-gui)
-find_package(Qt5Widgets REQUIRED)
+set (QT_COMPONENTS
+  Core
+  Widgets
+  Gui
+)
+
+set(CMake_QT_MAJOR_VERSION "A" CACHE
+  STRING "Expected Qt major version. Valid values are A (auto-select), 5, 6.")
+set(SUPPORTED_QT_VERSIONS "A" 5 6)
+set_property(CACHE CMake_QT_MAJOR_VERSION PROPERTY STRINGS ${SUPPORTED_QT_VERSIONS})
+if(NOT CMake_QT_MAJOR_VERSION STREQUAL "A")
+  if(NOT CMake_QT_MAJOR_VERSION IN_LIST SUPPORTED_QT_VERSIONS)
+    message(FATAL_ERROR "Supported Qt versions are \"${SUPPORTED_QT_VERSIONS}\"."
+            " But CMake_QT_MAJOR_VERSION is set to ${CMake_QT_MAJOR_VERSION}.")
+  endif()
+  set(INSTALLED_QT_VERSION ${CMake_QT_MAJOR_VERSION})
+else()
+  find_package(Qt6Widgets QUIET)
+  set(INSTALLED_QT_VERSION 6)
+  if(NOT Qt6Widgets_FOUND)
+    find_package(Qt5Widgets QUIET)
+    if(NOT Qt5Widgets_FOUND)
+      message(FATAL_ERROR "Could not find a valid Qt installation.")
+    endif()
+    set(INSTALLED_QT_VERSION 5)
+  endif()
+endif()
+
+find_package(Qt${INSTALLED_QT_VERSION}
+    COMPONENTS ${QT_COMPONENTS}
+    REQUIRED QUIET
+)
 
 set(CMake_QT_EXTRA_LIBRARIES)
 
 # Try to find the package WinExtras for the task bar progress
 if(WIN32)
-  find_package(Qt5WinExtras QUIET)
-  if (Qt5WinExtras_FOUND)
+  find_package(Qt${INSTALLED_QT_VERSION}WinExtras QUIET)
+  if (Qt${INSTALLED_QT_VERSION}WinExtras_FOUND)
     add_definitions(-DQT_WINEXTRAS)
-    list(APPEND CMake_QT_EXTRA_LIBRARIES Qt5::WinExtras)
+    list(APPEND CMake_QT_EXTRA_LIBRARIES Qt${INSTALLED_QT_VERSION}::WinExtras)
+    list(APPEND QT_COMPONENTS WinExtras)
   endif()
 endif()
 
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${Qt5Widgets_EXECUTABLE_COMPILE_FLAGS}")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${Qt${INSTALLED_QT_VERSION}Widgets_EXECUTABLE_COMPILE_FLAGS}")
 
 if(CMake_QT_STATIC_QXcbIntegrationPlugin_LIBRARIES)
   list(APPEND CMake_QT_EXTRA_LIBRARIES ${CMake_QT_STATIC_QXcbIntegrationPlugin_LIBRARIES})
@@ -31,11 +63,25 @@
 endif()
 
 # We need to install platform plugin and add qt.conf for Qt5 on Mac and Windows.
-# FIXME: This should be part of Qt5 CMake scripts, but unfortunately
-# Qt5 support is missing there.
 if(CMake_INSTALL_DEPENDENCIES AND (APPLE OR WIN32))
-  macro(install_qt5_plugin _qt_plugin_name _qt_plugins_var)
-    get_target_property(_qt_plugin_path "${_qt_plugin_name}" LOCATION)
+  function(_qt_get_plugin_name_with_version target out_var)
+      string(REGEX REPLACE "^Qt::(.+)" "Qt${INSTALLED_QT_VERSION}::\\1"
+             qt_plugin_with_version "${target}")
+      if(TARGET "${qt_plugin_with_version}")
+          set("${out_var}" "${qt_plugin_with_version}" PARENT_SCOPE)
+      else()
+          set("${out_var}" "" PARENT_SCOPE)
+      endif()
+  endfunction()
+  macro(install_qt_plugin _qt_plugin_name _qt_plugins_var)
+    if(TARGET "${_qt_plugin_name}")
+      get_target_property(_qt_plugin_path "${_qt_plugin_name}" LOCATION)
+    else()
+      _qt_get_plugin_name_with_version("Qt::${_qt_plugin_name}" _qt_plugin_with_version_name)
+      if(TARGET "${_qt_plugin_with_version_name}")
+        get_target_property(_qt_plugin_path "${_qt_plugin_with_version_name}" LOCATION)
+      endif()
+    endif()
     if(EXISTS "${_qt_plugin_path}")
       get_filename_component(_qt_plugin_file "${_qt_plugin_path}" NAME)
       get_filename_component(_qt_plugin_type "${_qt_plugin_path}" PATH)
@@ -51,19 +97,47 @@
         ${COMPONENT})
       set(${_qt_plugins_var}
         "${${_qt_plugins_var}};\$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/${_qt_plugin_dest}/${_qt_plugin_file}")
-    else()
-      message(FATAL_ERROR "QT plugin ${_qt_plugin_name} not found")
     endif()
   endmacro()
+  macro(install_qt_plugins _comps _plugins_var)
+    foreach(_qt_comp ${${_comps}})
+      if (INSTALLED_QT_VERSION VERSION_LESS 6)
+        set(_qt_module_plugins ${Qt${INSTALLED_QT_VERSION}${_qt_comp}_PLUGINS})
+      else()
+        get_target_property(_qt_module_plugins Qt${INSTALLED_QT_VERSION}::${_qt_comp} QT_PLUGINS)
+      endif()
+      foreach(_qt_plugin ${_qt_module_plugins})
+        if (INSTALLED_QT_VERSION VERSION_GREATER_EQUAL 6)
+          # Qt6 provides the plugins as individual packages that need to be found.
+          find_package(Qt${INSTALLED_QT_VERSION}${_qt_plugin} QUIET
+            PATHS ${Qt${INSTALLED_QT_VERSION}${_qt_comp}_DIR})
+        endif()
+        install_qt_plugin("${_qt_plugin}" "${_plugins_var}")
+      endforeach()
+    endforeach()
+  endmacro()
   if(APPLE)
-    install_qt5_plugin("Qt5::QCocoaIntegrationPlugin" QT_PLUGINS)
+    if (INSTALLED_QT_VERSION VERSION_EQUAL 5)
+      install_qt_plugin("Qt5::QCocoaIntegrationPlugin" QT_PLUGINS)
+      if(TARGET Qt5::QMacStylePlugin)
+        install_qt_plugin("Qt5::QMacStylePlugin" QT_PLUGINS)
+      endif()
+    else()
+      # FIXME: Minimize plugins for Qt6.
+      install_qt_plugins(QT_COMPONENTS QT_PLUGINS)
+    endif()
     file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/qt.conf"
       "[Paths]\nPlugins = ${_qt_plugin_dir}\n")
     install(FILES "${CMAKE_CURRENT_BINARY_DIR}/qt.conf"
       DESTINATION "${CMAKE_INSTALL_PREFIX}/Resources"
       ${COMPONENT})
   elseif(WIN32 AND NOT CMake_QT_STATIC_QWindowsIntegrationPlugin_LIBRARIES)
-    install_qt5_plugin("Qt5::QWindowsIntegrationPlugin" QT_PLUGINS)
+    if (INSTALLED_QT_VERSION VERSION_EQUAL 5)
+      install_qt_plugin("Qt5::QWindowsIntegrationPlugin" QT_PLUGINS)
+    else()
+      # FIXME: Minimize plugins for Qt6.
+      install_qt_plugins(QT_COMPONENTS QT_PLUGINS)
+    endif()
     file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/qt.conf"
       "[Paths]\nPlugins = ../${_qt_plugin_dir}\n")
     install(FILES "${CMAKE_CURRENT_BINARY_DIR}/qt.conf"
@@ -72,8 +146,8 @@
   endif()
 endif()
 
-get_property(_Qt5_Core_LOCATION TARGET Qt5::Core PROPERTY LOCATION)
-get_filename_component(Qt_BIN_DIR "${_Qt5_Core_LOCATION}" PATH)
+get_property(_Qt_Core_LOCATION TARGET Qt${INSTALLED_QT_VERSION}::Core PROPERTY LOCATION)
+get_filename_component(Qt_BIN_DIR "${_Qt_Core_LOCATION}" PATH)
 if(APPLE)
   get_filename_component(Qt_BIN_DIR "${Qt_BIN_DIR}" PATH)
 endif()
@@ -105,7 +179,7 @@
   WarningMessagesDialog.cxx
   WarningMessagesDialog.h
   )
-qt5_wrap_ui(UI_SRCS
+set(UI_SRCS
   CMakeSetupDialog.ui
   Compilers.ui
   CrossCompiler.ui
@@ -114,7 +188,7 @@
   RegexExplorer.ui
   WarningMessagesDialog.ui
   )
-qt5_wrap_cpp(MOC_SRCS
+set(MOC_SRCS
   AddCacheEntry.h
   Compilers.h
   CMakeSetupDialog.h
@@ -128,7 +202,18 @@
   RegexExplorer.h
   WarningMessagesDialog.h
   )
-qt5_add_resources(RC_SRCS CMakeSetup.qrc)
+set(QRC_SRCS CMakeSetup.qrc)
+
+if (INSTALLED_QT_VERSION VERSION_LESS 6)
+  qt5_wrap_ui(UI_BUILT_SRCS ${UI_SRCS})
+  qt5_wrap_cpp(MOC_BUILT_SRCS ${MOC_SRCS})
+  qt5_add_resources(QRC_BUILT_SRCS ${QRC_SRCS})
+else()
+  qt_wrap_ui(UI_BUILT_SRCS ${UI_SRCS})
+  qt_wrap_cpp(MOC_BUILT_SRCS ${MOC_SRCS})
+  qt_add_resources(QRC_BUILT_SRCS ${QRC_SRCS})
+endif()
+add_library(CMakeGUIQRCLib OBJECT ${QRC_BUILT_SRCS})
 
 if (FALSE) # CMake's bootstrap binary does not support automoc
   set(CMAKE_AUTOMOC 1)
@@ -136,9 +221,8 @@
   set(CMAKE_AUTOUIC 1)
 else ()
   list(APPEND SRCS
-    ${UI_SRCS}
-    ${MOC_SRCS}
-    ${RC_SRCS})
+    ${UI_BUILT_SRCS}
+    ${MOC_BUILT_SRCS})
 endif ()
 
 if(USE_LGPL)
@@ -153,14 +237,16 @@
 
 add_library(CMakeGUILib STATIC ${SRCS})
 # CMake_QT_EXTRA_LIBRARIES have to come before the main libraries on the link line
-target_link_libraries(CMakeGUILib PUBLIC CMakeLib ${CMake_QT_EXTRA_LIBRARIES} Qt5::Core Qt5::Widgets)
+target_link_libraries(CMakeGUILib PUBLIC CMakeLib ${CMake_QT_EXTRA_LIBRARIES}
+  Qt${INSTALLED_QT_VERSION}::Core Qt${INSTALLED_QT_VERSION}::Widgets)
 
 add_library(CMakeGUIMainLib STATIC CMakeSetup.cxx)
 target_link_libraries(CMakeGUIMainLib PUBLIC CMakeGUILib)
 
 add_executable(cmake-gui WIN32 MACOSX_BUNDLE CMakeGUIExec.cxx ${MANIFEST_FILE})
-target_link_libraries(cmake-gui CMakeGUIMainLib Qt5::Core)
+target_link_libraries(cmake-gui CMakeGUIMainLib Qt${INSTALLED_QT_VERSION}::Core)
 
+target_sources(CMakeGUIMainLib INTERFACE $<TARGET_OBJECTS:CMakeGUIQRCLib>)
 if(WIN32)
   target_sources(CMakeGUIMainLib INTERFACE $<TARGET_OBJECTS:CMakeVersion> CMakeSetup.rc)
 endif()
diff --git a/Source/QtDialog/CMakeSetup.cxx b/Source/QtDialog/CMakeSetup.cxx
index 861c6e3..5debdb8 100644
--- a/Source/QtDialog/CMakeSetup.cxx
+++ b/Source/QtDialog/CMakeSetup.cxx
@@ -7,7 +7,6 @@
 #include <QDir>
 #include <QLocale>
 #include <QString>
-#include <QTextCodec>
 #include <QTranslator>
 #include <QtPlugin>
 
@@ -122,9 +121,6 @@
 
   setlocale(LC_NUMERIC, "C");
 
-  QTextCodec* utf8_codec = QTextCodec::codecForName("UTF-8");
-  QTextCodec::setCodecForLocale(utf8_codec);
-
   // tell the cmake library where cmake is
   QDir cmExecDir(QApplication::applicationDirPath());
 #if defined(Q_OS_MAC)
diff --git a/Source/QtDialog/EnvironmentDialog.cxx b/Source/QtDialog/EnvironmentDialog.cxx
index 846456c..d4f978c 100644
--- a/Source/QtDialog/EnvironmentDialog.cxx
+++ b/Source/QtDialog/EnvironmentDialog.cxx
@@ -81,7 +81,11 @@
   auto* model = this->sourceModel();
   auto key =
     model->data(model->index(row, 0, parent), Qt::DisplayRole).toString();
+#if (QT_VERSION >= QT_VERSION_CHECK(5, 12, 0))
+  return key.contains(this->filterRegularExpression());
+#else
   return key.contains(this->filterRegExp());
+#endif
 }
 
 EnvironmentDialog::EnvironmentDialog(const QProcessEnvironment& environment,
diff --git a/Source/QtDialog/QCMakeCacheView.cxx b/Source/QtDialog/QCMakeCacheView.cxx
index 22f5be1..7c9032e 100644
--- a/Source/QtDialog/QCMakeCacheView.cxx
+++ b/Source/QtDialog/QCMakeCacheView.cxx
@@ -47,7 +47,11 @@
 
     // check all strings for a match
     foreach (QString const& str, strs) {
+#if (QT_VERSION >= QT_VERSION_CHECK(5, 12, 0))
+      if (str.contains(this->filterRegularExpression())) {
+#else
       if (str.contains(this->filterRegExp())) {
+#endif
         return true;
       }
     }
diff --git a/Source/QtDialog/QCMakeWidgets.cxx b/Source/QtDialog/QCMakeWidgets.cxx
index e68faba..ca65d13 100644
--- a/Source/QtDialog/QCMakeWidgets.cxx
+++ b/Source/QtDialog/QCMakeWidgets.cxx
@@ -1,20 +1,23 @@
 /* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
    file Copyright.txt or https://cmake.org/licensing for details.  */
 
-// FIXME: Port to QFileSystemModel from the deprecated QDirModel.
-// Be sure completion works when incrementally editing existing paths.
 #define QT_DEPRECATED_WARNINGS_SINCE QT_VERSION_CHECK(5, 14, 0)
 
 #include "QCMakeWidgets.h"
 
 #include <utility>
 
-#include <QDirModel>
 #include <QFileDialog>
 #include <QFileInfo>
 #include <QResizeEvent>
 #include <QToolButton>
 
+#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
+#  include <QFileSystemModel>
+#else
+#  include <QDirModel>
+#endif
+
 QCMakeFileEditor::QCMakeFileEditor(QWidget* p, QString var)
   : QLineEdit(p)
   , Variable(std::move(var))
@@ -93,8 +96,30 @@
   }
 }
 
+#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
+// use same QFileSystemModel for all completers
+static QFileSystemModel* fileDirModel()
+
+{
+  static QFileSystemModel* m = nullptr;
+  if (!m) {
+    m = new QFileSystemModel();
+  }
+  return m;
+}
+static QFileSystemModel* pathDirModel()
+{
+  static QFileSystemModel* m = nullptr;
+  if (!m) {
+    m = new QFileSystemModel();
+    m->setFilter(QDir::AllDirs | QDir::Drives | QDir::NoDotAndDotDot);
+  }
+  return m;
+}
+#else
 // use same QDirModel for all completers
 static QDirModel* fileDirModel()
+
 {
   static QDirModel* m = nullptr;
   if (!m) {
@@ -111,12 +136,19 @@
   }
   return m;
 }
+#endif
 
 QCMakeFileCompleter::QCMakeFileCompleter(QObject* o, bool dirs)
   : QCompleter(o)
 {
+#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
+  QFileSystemModel* m = dirs ? pathDirModel() : fileDirModel();
+  this->setModel(m);
+  m->setRootPath(QString());
+#else
   QDirModel* m = dirs ? pathDirModel() : fileDirModel();
   this->setModel(m);
+#endif
 }
 
 QString QCMakeFileCompleter::pathFromIndex(const QModelIndex& idx) const
diff --git a/Source/bindexplib.cxx b/Source/bindexplib.cxx
index 8435740..0dc954a 100644
--- a/Source/bindexplib.cxx
+++ b/Source/bindexplib.cxx
@@ -467,7 +467,7 @@
 
 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::SetNmPath(std::string const& nm)
 {
-  NmPath = nm;
+  this->NmPath = nm;
 }
diff --git a/Source/cmAlgorithms.h b/Source/cmAlgorithms.h
index 87000da..c192e2a 100644
--- a/Source/cmAlgorithms.h
+++ b/Source/cmAlgorithms.h
@@ -47,7 +47,8 @@
 
   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 0d33758..168d30e 100644
--- a/Source/cmArchiveWrite.h
+++ b/Source/cmArchiveWrite.h
@@ -26,7 +26,7 @@
   }
   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 85e7d9e..e9bf84a 100644
--- a/Source/cmCMakePathCommand.cxx
+++ b/Source/cmCMakePathCommand.cxx
@@ -37,7 +37,7 @@
   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 @@
   {
     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 @@
   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 @@
     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 014ce4e..6c1071d 100644
--- a/Source/cmCTest.cxx
+++ b/Source/cmCTest.cxx
@@ -1326,11 +1326,11 @@
   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: ",
@@ -2901,7 +2901,7 @@
 
 bool cmCTest::GetTestProgressOutput() const
 {
-  return this->Impl->TestProgressOutput;
+  return this->Impl->TestProgressOutput && !GetExtraVerbose();
 }
 
 bool cmCTest::GetVerbose() const
diff --git a/Source/cmCommandArgumentParserHelper.cxx b/Source/cmCommandArgumentParserHelper.cxx
index d4f5022..6d5e064 100644
--- a/Source/cmCommandArgumentParserHelper.cxx
+++ b/Source/cmCommandArgumentParserHelper.cxx
@@ -240,7 +240,7 @@
 
   this->CleanupParser();
 
-  if (Verbose) {
+  if (this->Verbose) {
     std::cerr << "Expanding [" << str << "] produced: [" << this->Result << "]"
               << std::endl;
   }
diff --git a/Source/cmCommandLineArgument.h b/Source/cmCommandLineArgument.h
new file mode 100644
index 0000000..cbedf0a
--- /dev/null
+++ b/Source/cmCommandLineArgument.h
@@ -0,0 +1,159 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#pragma once
+
+#include "cmStringAlgorithms.h"
+#include "cmSystemTools.h"
+
+template <typename FunctionSignature>
+struct cmCommandLineArgument
+{
+  enum class Values
+  {
+    Zero,
+    One,
+    Two,
+    ZeroOrOne,
+    OneOrMore
+  };
+
+  std::string InvalidSyntaxMessage;
+  std::string InvalidValueMessage;
+  std::string Name;
+  Values Type;
+  std::function<FunctionSignature> StoreCall;
+
+  template <typename FunctionType>
+  cmCommandLineArgument(std::string n, Values t, FunctionType&& func)
+    : InvalidSyntaxMessage(cmStrCat("Invalid syntax used with ", n))
+    , InvalidValueMessage(cmStrCat("Invalid value used with ", n))
+    , Name(std::move(n))
+    , Type(t)
+    , StoreCall(std::forward<FunctionType>(func))
+  {
+  }
+
+  template <typename FunctionType>
+  cmCommandLineArgument(std::string n, std::string failedMsg, Values t,
+                        FunctionType&& func)
+    : InvalidSyntaxMessage(cmStrCat("Invalid syntax used with ", n))
+    , InvalidValueMessage(std::move(failedMsg))
+    , Name(std::move(n))
+    , Type(t)
+    , StoreCall(std::forward<FunctionType>(func))
+  {
+  }
+
+  bool matches(std::string const& input) const
+  {
+    return (this->Type == Values::Zero) ? (input == this->Name)
+                                        : cmHasPrefix(input, this->Name);
+  }
+
+  template <typename T, typename... CallState>
+  bool parse(std::string const& input, T& index,
+             std::vector<std::string> const& allArgs,
+             CallState&&... state) const
+  {
+    enum class ParseMode
+    {
+      Valid,
+      Invalid,
+      SyntaxError,
+      ValueError
+    };
+    ParseMode parseState = ParseMode::Valid;
+
+    if (this->Type == Values::Zero) {
+      if (input.size() == this->Name.size()) {
+        parseState =
+          this->StoreCall(std::string{}, std::forward<CallState>(state)...)
+          ? ParseMode::Valid
+          : ParseMode::Invalid;
+      } else {
+        parseState = ParseMode::SyntaxError;
+      }
+
+    } else if (this->Type == Values::One || this->Type == Values::ZeroOrOne) {
+      if (input.size() == this->Name.size()) {
+        ++index;
+        if (index >= allArgs.size() || allArgs[index][0] == '-') {
+          if (this->Type == Values::ZeroOrOne) {
+            parseState =
+              this->StoreCall(std::string{}, std::forward<CallState>(state)...)
+              ? ParseMode::Valid
+              : ParseMode::Invalid;
+          } else {
+            parseState = ParseMode::ValueError;
+          }
+        } else {
+          parseState =
+            this->StoreCall(allArgs[index], std::forward<CallState>(state)...)
+            ? ParseMode::Valid
+            : ParseMode::Invalid;
+        }
+      } else {
+        // parse the string to get the value
+        auto possible_value = cm::string_view(input).substr(this->Name.size());
+        if (possible_value.empty()) {
+          parseState = ParseMode::SyntaxError;
+          parseState = ParseMode::ValueError;
+        } else if (possible_value[0] == '=') {
+          possible_value.remove_prefix(1);
+          if (possible_value.empty()) {
+            parseState = ParseMode::ValueError;
+          } else {
+            parseState = this->StoreCall(std::string(possible_value),
+                                         std::forward<CallState>(state)...)
+              ? ParseMode::Valid
+              : ParseMode::Invalid;
+          }
+        }
+        if (parseState == ParseMode::Valid) {
+          parseState = this->StoreCall(std::string(possible_value),
+                                       std::forward<CallState>(state)...)
+            ? ParseMode::Valid
+            : ParseMode::Invalid;
+        }
+      }
+    } else if (this->Type == Values::Two) {
+      if (input.size() == this->Name.size()) {
+        if (index + 2 >= allArgs.size() || allArgs[index + 1][0] == '-' ||
+            allArgs[index + 2][0] == '-') {
+          parseState = ParseMode::ValueError;
+        } else {
+          index += 2;
+          parseState =
+            this->StoreCall(cmStrCat(allArgs[index - 1], ";", allArgs[index]),
+                            std::forward<CallState>(state)...)
+            ? ParseMode::Valid
+            : ParseMode::Invalid;
+        }
+      }
+    } else if (this->Type == Values::OneOrMore) {
+      if (input.size() == this->Name.size()) {
+        auto nextValueIndex = index + 1;
+        if (nextValueIndex >= allArgs.size() || allArgs[index + 1][0] == '-') {
+          parseState = ParseMode::ValueError;
+        } else {
+          std::string buffer = allArgs[nextValueIndex++];
+          while (nextValueIndex < allArgs.size() &&
+                 allArgs[nextValueIndex][0] != '-') {
+            buffer = cmStrCat(buffer, ";", allArgs[nextValueIndex++]);
+          }
+          parseState =
+            this->StoreCall(buffer, std::forward<CallState>(state)...)
+            ? ParseMode::Valid
+            : ParseMode::Invalid;
+        }
+      }
+    }
+
+    if (parseState == ParseMode::SyntaxError) {
+      cmSystemTools::Error(this->InvalidSyntaxMessage);
+    } else if (parseState == ParseMode::ValueError) {
+      cmSystemTools::Error(this->InvalidValueMessage);
+    }
+    return (parseState == ParseMode::Valid);
+  }
+};
diff --git a/Source/cmCommonTargetGenerator.cxx b/Source/cmCommonTargetGenerator.cxx
index 2b7c9f6..228cff7 100644
--- a/Source/cmCommonTargetGenerator.cxx
+++ b/Source/cmCommonTargetGenerator.cxx
@@ -27,7 +27,7 @@
       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 1f22ce6..85a9d9c 100644
--- a/Source/cmComputeTargetDepends.cxx
+++ b/Source/cmComputeTargetDepends.cxx
@@ -525,7 +525,7 @@
 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 14f10bd74..62bc526 100644
--- a/Source/cmConditionEvaluator.cxx
+++ b/Source/cmConditionEvaluator.cxx
@@ -271,10 +271,10 @@
 {
   // 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 @@
     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 @@
       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 @@
     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 @@
     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 b1e63ba..b331862 100644
--- a/Source/cmCryptoHash.cxx
+++ b/Source/cmCryptoHash.cxx
@@ -36,7 +36,7 @@
 
 cmCryptoHash::cmCryptoHash(Algo algo)
   : Id(cmCryptoHashAlgoToId[algo])
-  , CTX(cmCryptoHash_rhash_init(Id))
+  , CTX(cmCryptoHash_rhash_init(this->Id))
 {
 }
 
diff --git a/Source/cmDependsC.cxx b/Source/cmDependsC.cxx
index e6aef92..60e8cbf 100644
--- a/Source/cmDependsC.cxx
+++ b/Source/cmDependsC.cxx
@@ -7,6 +7,7 @@
 #include "cmsys/FStream.hxx"
 
 #include "cmFileTime.h"
+#include "cmGlobalUnixMakefileGenerator3.h"
 #include "cmLocalUnixMakefileGenerator3.h"
 #include "cmMakefile.h"
 #include "cmProperty.h"
@@ -215,16 +216,28 @@
   // directory.  We must do the same here.
   std::string obj_m = this->LocalGenerator->ConvertToMakefilePath(obj_i);
   internalDepends << obj_i << '\n';
-
-  for (std::string const& dep : dependencies) {
-    makeDepends << obj_m << ": "
-                << this->LocalGenerator->ConvertToMakefilePath(
-                     this->LocalGenerator->MaybeConvertToRelativePath(binDir,
-                                                                      dep))
-                << '\n';
-    internalDepends << ' ' << dep << '\n';
+  if (!dependencies.empty()) {
+    const auto& lineContinue = static_cast<cmGlobalUnixMakefileGenerator3*>(
+                                 this->LocalGenerator->GetGlobalGenerator())
+                                 ->LineContinueDirective;
+    bool supportLongLineDepend = static_cast<cmGlobalUnixMakefileGenerator3*>(
+                                   this->LocalGenerator->GetGlobalGenerator())
+                                   ->SupportsLongLineDependencies();
+    if (supportLongLineDepend) {
+      makeDepends << obj_m << ':';
+    }
+    for (std::string const& dep : dependencies) {
+      std::string dependee = this->LocalGenerator->ConvertToMakefilePath(
+        this->LocalGenerator->MaybeConvertToRelativePath(binDir, dep));
+      if (supportLongLineDepend) {
+        makeDepends << ' ' << lineContinue << ' ' << dependee;
+      } else {
+        makeDepends << obj_m << ": " << dependee << '\n';
+      }
+      internalDepends << ' ' << dep << '\n';
+    }
+    makeDepends << '\n';
   }
-  makeDepends << '\n';
 
   return true;
 }
diff --git a/Source/cmDependsCompiler.cxx b/Source/cmDependsCompiler.cxx
index beb080f..ec31f68 100644
--- a/Source/cmDependsCompiler.cxx
+++ b/Source/cmDependsCompiler.cxx
@@ -196,30 +196,39 @@
   const auto& lineContinue = static_cast<cmGlobalUnixMakefileGenerator3*>(
                                this->LocalGenerator->GetGlobalGenerator())
                                ->LineContinueDirective;
+  bool supportLongLineDepend = static_cast<cmGlobalUnixMakefileGenerator3*>(
+                                 this->LocalGenerator->GetGlobalGenerator())
+                                 ->SupportsLongLineDependencies();
   const auto& binDir = this->LocalGenerator->GetBinaryDirectory();
   cmDepends::DependencyMap makeDependencies(dependencies);
   std::unordered_set<cm::string_view> phonyTargets;
 
   // 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));
       });
 
     bool first_dep = true;
-    makeDepends << target << ": ";
+    if (supportLongLineDepend) {
+      makeDepends << target << ": ";
+    }
     for (const auto& dep : deps) {
-      if (first_dep) {
-        first_dep = false;
-        makeDepends << dep;
+      if (supportLongLineDepend) {
+        if (first_dep) {
+          first_dep = false;
+          makeDepends << dep;
+        } else {
+          makeDepends << ' ' << lineContinue << "  " << dep;
+        }
       } else {
-        makeDepends << ' ' << lineContinue << "  " << dep;
+        makeDepends << target << ": " << dep << std::endl;
       }
 
       phonyTargets.emplace(dep.data(), dep.length());
diff --git a/Source/cmDependsFortran.cxx b/Source/cmDependsFortran.cxx
index a239418..1a06f31 100644
--- a/Source/cmDependsFortran.cxx
+++ b/Source/cmDependsFortran.cxx
@@ -12,6 +12,7 @@
 
 #include "cmFortranParser.h" /* Interface to parser object.  */
 #include "cmGeneratedFileStream.h"
+#include "cmGlobalUnixMakefileGenerator3.h"
 #include "cmLocalUnixMakefileGenerator3.h"
 #include "cmMakefile.h"
 #include "cmOutputConverter.h"
@@ -320,14 +321,28 @@
   std::string obj_i = this->MaybeConvertToRelativePath(binDir, obj);
   std::string obj_m = cmSystemTools::ConvertToOutputPath(obj_i);
   internalDepends << obj_i << "\n " << src << '\n';
-  for (std::string const& i : info.Includes) {
-    makeDepends << obj_m << ": "
-                << cmSystemTools::ConvertToOutputPath(
-                     this->MaybeConvertToRelativePath(binDir, i))
-                << '\n';
-    internalDepends << ' ' << i << '\n';
+  if (!info.Includes.empty()) {
+    const auto& lineContinue = static_cast<cmGlobalUnixMakefileGenerator3*>(
+                                 this->LocalGenerator->GetGlobalGenerator())
+                                 ->LineContinueDirective;
+    bool supportLongLineDepend = static_cast<cmGlobalUnixMakefileGenerator3*>(
+                                   this->LocalGenerator->GetGlobalGenerator())
+                                   ->SupportsLongLineDependencies();
+    if (supportLongLineDepend) {
+      makeDepends << obj_m << ':';
+    }
+    for (std::string const& i : info.Includes) {
+      std::string dependee = cmSystemTools::ConvertToOutputPath(
+        this->MaybeConvertToRelativePath(binDir, i));
+      if (supportLongLineDepend) {
+        makeDepends << ' ' << lineContinue << ' ' << dependee;
+      } else {
+        makeDepends << obj_m << ": " << dependee << '\n';
+      }
+      internalDepends << ' ' << i << '\n';
+    }
+    makeDepends << '\n';
   }
-  makeDepends << '\n';
 
   // Write module requirements to the output stream.
   for (std::string const& i : info.Requires) {
diff --git a/Source/cmDocumentation.cxx b/Source/cmDocumentation.cxx
index 1bc453d..3619ade 100644
--- a/Source/cmDocumentation.cxx
+++ b/Source/cmDocumentation.cxx
@@ -194,7 +194,7 @@
 {
   // 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 a8d81f7..deffdb6 100644
--- a/Source/cmELF.cxx
+++ b/Source/cmELF.cxx
@@ -379,7 +379,7 @@
 
     // Fix the byte order of the header.
     if (this->NeedSwap) {
-      ByteSwap(x);
+      this->ByteSwap(x);
     }
     return true;
   }
@@ -387,7 +387,7 @@
   {
     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 @@
   {
     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 @@
     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/cmExportFileGenerator.cxx b/Source/cmExportFileGenerator.cxx
index a853bb1..113751a 100644
--- a/Source/cmExportFileGenerator.cxx
+++ b/Source/cmExportFileGenerator.cxx
@@ -707,7 +707,7 @@
       break;
     }
     input.replace(pos, endPos - pos + 1, targetName);
-    lastPos = endPos;
+    lastPos = pos + targetName.size();
   }
 
   pos = 0;
diff --git a/Source/cmExprParserHelper.cxx b/Source/cmExprParserHelper.cxx
index 56dfc6c..cc8b8b7 100644
--- a/Source/cmExprParserHelper.cxx
+++ b/Source/cmExprParserHelper.cxx
@@ -42,20 +42,22 @@
   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 @@
     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 3ade67b..311a2ef 100644
--- a/Source/cmExternalMakefileProjectGenerator.h
+++ b/Source/cmExternalMakefileProjectGenerator.h
@@ -52,8 +52,8 @@
   //! 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 @@
   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 87b8f9b..800db8a 100644
--- a/Source/cmExtraCodeBlocksGenerator.cxx
+++ b/Source/cmExtraCodeBlocksGenerator.cxx
@@ -112,10 +112,10 @@
                       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 @@
   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::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 @@
 
     xml.EndElement();
   }
-  for (Tree const& folder : folders) {
+  for (Tree const& folder : this->folders) {
     folder.BuildUnitImpl(xml, "", fsPath);
   }
 }
@@ -180,20 +180,21 @@
                          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 95cfb0a..549b08b 100644
--- a/Source/cmExtraCodeLiteGenerator.cxx
+++ b/Source/cmExtraCodeLiteGenerator.cxx
@@ -64,7 +64,7 @@
   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 @@
 
   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 @@
           xml->Attribute("Active", "No");
           xml->EndElement();
 
-          CreateNewProjectFile(lt.get(), filename);
+          this->CreateNewProjectFile(lt.get(), filename);
           break;
         default:
           break;
@@ -268,7 +268,7 @@
     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 @@
   // 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 @@
   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 @@
 
   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 @@
   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 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::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 249dfaf..a92f6e3 100644
--- a/Source/cmExtraSublimeTextGenerator.cxx
+++ b/Source/cmExtraSublimeTextGenerator.cxx
@@ -132,7 +132,7 @@
   // 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 1e4f3b6..e208ca8 100644
--- a/Source/cmFileAPICMakeFiles.cxx
+++ b/Source/cmFileAPICMakeFiles.cxx
@@ -41,7 +41,7 @@
   , 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 = 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 3ba943a..ddae527 100644
--- a/Source/cmFileAPICache.cxx
+++ b/Source/cmFileAPICache.cxx
@@ -44,7 +44,7 @@
 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 4a53c8a..7fcc3dc 100644
--- a/Source/cmFileAPICodemodel.cxx
+++ b/Source/cmFileAPICodemodel.cxx
@@ -145,7 +145,7 @@
 {
 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 bb3f610..6b52230 100644
--- a/Source/cmFilePathChecksum.cxx
+++ b/Source/cmFilePathChecksum.cxx
@@ -16,15 +16,16 @@
                                        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::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 d8fe24c..bd896f5 100644
--- a/Source/cmFileTimes.cxx
+++ b/Source/cmFileTimes.cxx
@@ -62,14 +62,14 @@
 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::Store(std::string const& fileName) const
 {
-  if (!IsValid()) {
+  if (!this->IsValid()) {
     return false;
   }
 
diff --git a/Source/cmFileTimes.h b/Source/cmFileTimes.h
index f1916f7..50d64fd 100644
--- a/Source/cmFileTimes.h
+++ b/Source/cmFileTimes.h
@@ -19,7 +19,7 @@
   ~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 7952336..d2f9619 100644
--- a/Source/cmFindCommon.cxx
+++ b/Source/cmFindCommon.cxx
@@ -289,7 +289,7 @@
 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 b87dfe3..49b1bd7 100644
--- a/Source/cmFindLibraryCommand.cxx
+++ b/Source/cmFindLibraryCommand.cxx
@@ -31,7 +31,7 @@
 // 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 92b1e80..3b7cf4c 100644
--- a/Source/cmFindPackageCommand.cxx
+++ b/Source/cmFindPackageCommand.cxx
@@ -144,7 +144,7 @@
     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 @@
         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 @@
   void SetSort(cmFindPackageCommand::SortOrderType o,
                cmFindPackageCommand::SortDirectionType d)
   {
-    SortOrder = o;
-    SortDirection = d;
+    this->SortOrder = o;
+    this->SortDirection = d;
   }
 
 protected:
@@ -2102,8 +2102,8 @@
     // 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 4bab469..bece33b 100644
--- a/Source/cmFindPathCommand.cxx
+++ b/Source/cmFindPathCommand.cxx
@@ -22,7 +22,7 @@
 // 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 77728ec..5bb4234 100644
--- a/Source/cmFindProgramCommand.cxx
+++ b/Source/cmFindProgramCommand.cxx
@@ -152,7 +152,7 @@
 // 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 @@
     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 program;
 
   if (this->SearchAppBundleFirst || this->SearchAppBundleOnly) {
-    program = FindAppBundle();
+    program = this->FindAppBundle();
   }
   if (program.empty() && !this->SearchAppBundleOnly) {
     program = this->FindNormalProgram();
@@ -274,7 +274,7 @@
       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/cmGccDepfileReader.cxx b/Source/cmGccDepfileReader.cxx
index 96a562e..8253375 100644
--- a/Source/cmGccDepfileReader.cxx
+++ b/Source/cmGccDepfileReader.cxx
@@ -12,40 +12,33 @@
 #include "cmStringAlgorithms.h"
 #include "cmSystemTools.h"
 
-cm::optional<cmGccDepfileContent> cmReadGccDepfile(const char* filePath)
-{
-  cmGccDepfileLexerHelper helper;
-  if (helper.readFile(filePath)) {
-    return cm::make_optional(std::move(helper).extractContent());
-  }
-  return cm::nullopt;
-}
-
 cm::optional<cmGccDepfileContent> cmReadGccDepfile(const char* filePath,
                                                    const std::string& prefix)
 {
-  auto deps = cmReadGccDepfile(filePath);
-
-  if (prefix.empty() || !deps) {
-    return deps;
+  cmGccDepfileLexerHelper helper;
+  if (!helper.readFile(filePath)) {
+    return cm::nullopt;
   }
+  auto deps = cm::make_optional(std::move(helper).extractContent());
 
   for (auto& dep : *deps) {
     for (auto& rule : dep.rules) {
-      if (!cmSystemTools::FileIsFullPath(rule)) {
+      if (!prefix.empty() && !cmSystemTools::FileIsFullPath(rule)) {
         rule = cmStrCat(prefix, rule);
       }
       if (cmSystemTools::FileIsFullPath(rule)) {
         rule = cmSystemTools::CollapseFullPath(rule);
       }
+      cmSystemTools::ConvertToLongPath(rule);
     }
     for (auto& path : dep.paths) {
-      if (!cmSystemTools::FileIsFullPath(path)) {
+      if (!prefix.empty() && !cmSystemTools::FileIsFullPath(path)) {
         path = cmStrCat(prefix, path);
       }
       if (cmSystemTools::FileIsFullPath(path)) {
         path = cmSystemTools::CollapseFullPath(path);
       }
+      cmSystemTools::ConvertToLongPath(path);
     }
   }
 
diff --git a/Source/cmGccDepfileReader.h b/Source/cmGccDepfileReader.h
index 66ff75d..c8a3748 100644
--- a/Source/cmGccDepfileReader.h
+++ b/Source/cmGccDepfileReader.h
@@ -8,10 +8,8 @@
 
 #include "cmGccDepfileReaderTypes.h"
 
-cm::optional<cmGccDepfileContent> cmReadGccDepfile(const char* filePath);
-
 /*
  * Read dependencies file and append prefix to all relative paths
  */
-cm::optional<cmGccDepfileContent> cmReadGccDepfile(const char* filePath,
-                                                   const std::string& prefix);
+cm::optional<cmGccDepfileContent> cmReadGccDepfile(
+  const char* filePath, const std::string& prefix = {});
diff --git a/Source/cmGeneratedFileStream.cxx b/Source/cmGeneratedFileStream.cxx
index 2768547..43f384a 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(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 @@
   }
 #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 e223f15..a1fce55 100644
--- a/Source/cmGeneratorExpressionDAGChecker.cxx
+++ b/Source/cmGeneratorExpressionDAGChecker.cxx
@@ -28,7 +28,7 @@
   , Backtrace(std::move(backtrace))
   , TransitivePropertiesOnly(false)
 {
-  Initialize();
+  this->Initialize();
 }
 
 cmGeneratorExpressionDAGChecker::cmGeneratorExpressionDAGChecker(
@@ -42,7 +42,7 @@
   , Backtrace()
   , TransitivePropertiesOnly(false)
 {
-  Initialize();
+  this->Initialize();
 }
 
 void cmGeneratorExpressionDAGChecker::Initialize()
@@ -52,7 +52,7 @@
 
 #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 af129d3..ec44df3 100644
--- a/Source/cmGeneratorExpressionEvaluationFile.cxx
+++ b/Source/cmGeneratorExpressionEvaluationFile.cxx
@@ -39,7 +39,7 @@
   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 @@
 {
   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 a7f090a..b8c38c0 100644
--- a/Source/cmGeneratorExpressionLexer.cxx
+++ b/Source/cmGeneratorExpressionLexer.cxx
@@ -35,14 +35,14 @@
                               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 c2c9ef7..794c1a1 100644
--- a/Source/cmGeneratorExpressionParser.cxx
+++ b/Source/cmGeneratorExpressionParser.cxx
@@ -22,7 +22,7 @@
 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 e2943d6..17d211e 100644
--- a/Source/cmGeneratorTarget.cxx
+++ b/Source/cmGeneratorTarget.cxx
@@ -557,7 +557,7 @@
 
     // 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 @@
 
     if (!this->IsImported() && postfix &&
         (this->IsFrameworkOnApple() &&
-         !GetGlobalGenerator()->IsMultiConfig())) {
+         !this->GetGlobalGenerator()->IsMultiConfig())) {
       postfix = nullptr;
     }
   }
@@ -2503,7 +2503,7 @@
 
   bool GetHadLinkLanguageSensitiveCondition() const
   {
-    return HadLinkLanguageSensitiveCondition;
+    return this->HadLinkLanguageSensitiveCondition;
   }
 
 private:
@@ -3278,7 +3278,7 @@
       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 @@
   // 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 51369c2..8fe70ab 100644
--- a/Source/cmGeneratorTarget.h
+++ b/Source/cmGeneratorTarget.h
@@ -585,7 +585,8 @@
     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 aabe43c..a7658f2 100644
--- a/Source/cmGhsMultiTargetGenerator.cxx
+++ b/Source/cmGhsMultiTargetGenerator.cxx
@@ -62,7 +62,7 @@
       // 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 @@
       }
     } 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 @@
   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/cmGlobalBorlandMakefileGenerator.cxx b/Source/cmGlobalBorlandMakefileGenerator.cxx
index 06943e7..996fcff 100644
--- a/Source/cmGlobalBorlandMakefileGenerator.cxx
+++ b/Source/cmGlobalBorlandMakefileGenerator.cxx
@@ -26,6 +26,15 @@
   this->DefineWindowsNULL = true;
   this->PassMakeflags = true;
   this->UnixCD = false;
+
+  /*
+   * Borland Make does not support long line depend rule, as we have tested
+   * generate one source file includes 40000 header files, and generate
+   * depend.make in one line(use line continued tag), and error occured:
+   * ** Fatal CMakeFiles\main.dir\depend.make 1224: Rule line too long **
+   * we disable long line dependencies rule generation for Borland make
+   */
+  this->ToolSupportsLongLineDependencies = false;
 }
 
 void cmGlobalBorlandMakefileGenerator::EnableLanguage(
diff --git a/Source/cmGlobalGenerator.h b/Source/cmGlobalGenerator.h
index 69373bd..86fb228 100644
--- a/Source/cmGlobalGenerator.h
+++ b/Source/cmGlobalGenerator.h
@@ -69,17 +69,17 @@
   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 @@
     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 33bf830..0ddfe77 100644
--- a/Source/cmGlobalGhsMultiGenerator.cxx
+++ b/Source/cmGlobalGhsMultiGenerator.cxx
@@ -366,7 +366,7 @@
         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 @@
         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 @@
     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 @@
     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 @@
   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 @@
   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/cmGlobalNMakeMakefileGenerator.cxx b/Source/cmGlobalNMakeMakefileGenerator.cxx
index c4bec23..36f583f 100644
--- a/Source/cmGlobalNMakeMakefileGenerator.cxx
+++ b/Source/cmGlobalNMakeMakefileGenerator.cxx
@@ -21,6 +21,8 @@
   this->PassMakeflags = true;
   this->UnixCD = false;
   this->MakeSilentFlag = "/nologo";
+  // nmake breaks on '!' in long-line dependencies
+  this->ToolSupportsLongLineDependencies = false;
 }
 
 void cmGlobalNMakeMakefileGenerator::EnableLanguage(
diff --git a/Source/cmGlobalNinjaGenerator.cxx b/Source/cmGlobalNinjaGenerator.cxx
index a098f81..4f17408 100644
--- a/Source/cmGlobalNinjaGenerator.cxx
+++ b/Source/cmGlobalNinjaGenerator.cxx
@@ -182,7 +182,7 @@
   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 @@
   {
     // 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 @@
     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 @@
 
     // 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 @@
     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 @@
 #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::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);
@@ -555,6 +555,7 @@
   this->TargetAll = this->NinjaOutputPath("all");
   this->CMakeCacheFile = this->NinjaOutputPath("CMakeCache.txt");
   this->DisableCleandead = false;
+  this->DiagnosedCxxModuleSupport = false;
 
   this->PolicyCMP0058 =
     this->LocalGenerators[0]->GetMakefile()->GetPolicyStatus(
@@ -755,6 +756,37 @@
   return true;
 }
 
+bool cmGlobalNinjaGenerator::CheckCxxModuleSupport()
+{
+  bool const diagnose = !this->DiagnosedCxxModuleSupport &&
+    !this->CMakeInstance->GetIsInTryCompile();
+  if (diagnose) {
+    this->DiagnosedCxxModuleSupport = true;
+    this->GetCMakeInstance()->IssueMessage(
+      MessageType::AUTHOR_WARNING,
+      "C++20 modules support via CMAKE_EXPERIMENTAL_CXX_MODULE_DYNDEP "
+      "is experimental.  It is meant only for compiler developers to try.");
+  }
+  if (this->NinjaSupportsDyndeps) {
+    return true;
+  }
+  if (diagnose) {
+    std::ostringstream e;
+    /* clang-format off */
+    e <<
+      "The Ninja generator does not support C++20 modules "
+      "using Ninja version \n"
+      "  " << this->NinjaVersion << "\n"
+      "due to lack of required features.  "
+      "Ninja " << RequiredNinjaVersionForDyndeps() << " or higher is required."
+      ;
+    /* clang-format on */
+    this->GetCMakeInstance()->IssueMessage(MessageType::FATAL_ERROR, e.str());
+    cmSystemTools::SetFatalErrorOccured();
+  }
+  return false;
+}
+
 bool cmGlobalNinjaGenerator::CheckFortran(cmMakefile* mf) const
 {
   if (this->NinjaSupportsDyndeps) {
@@ -766,7 +798,8 @@
   e <<
     "The Ninja generator does not support Fortran using Ninja version\n"
     "  " << this->NinjaVersion << "\n"
-    "due to lack of required features.  Ninja 1.10 or higher is required."
+    "due to lack of required features.  "
+    "Ninja " << RequiredNinjaVersionForDyndeps() << " or higher is required."
     ;
   /* clang-format on */
   mf->IssueMessage(MessageType::FATAL_ERROR, e.str());
@@ -785,7 +818,9 @@
   e <<
     "The Ninja generator does not support ISPC using Ninja version\n"
     "  " << this->NinjaVersion << "\n"
-    "due to lack of required features.  Ninja 1.10 or higher is required."
+    "due to lack of required features.  "
+    "Ninja " << RequiredNinjaVersionForMultipleOutputs() <<
+    " or higher is required."
     ;
   /* clang-format on */
   mf->IssueMessage(MessageType::FATAL_ERROR, e.str());
@@ -1032,8 +1067,8 @@
 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 +1080,7 @@
 #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 +1152,13 @@
     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 +1183,7 @@
     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 +1195,7 @@
     }
     case cmStateEnums::OBJECT_LIBRARY: {
       if (depends == DependOnTargetOrdering) {
-        outputs.push_back(OrderDependsTargetForTarget(target, config));
+        outputs.push_back(this->OrderDependsTargetForTarget(target, config));
         break;
       }
     }
@@ -1476,7 +1512,7 @@
       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 +1725,7 @@
   {
     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 +1750,7 @@
 
   // 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 +1759,7 @@
     {
       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 +1820,8 @@
     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 +1905,8 @@
         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 +1921,7 @@
   {
     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 +1938,13 @@
       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 +1954,13 @@
 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 +2061,13 @@
     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 +2076,7 @@
 {
   {
     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 +2085,7 @@
     cmNinjaBuild build("HELP");
     build.Comment = "Print all primary targets available.";
     build.Outputs.push_back(this->NinjaOutputPath("help"));
-    WriteBuild(os, build);
+    this->WriteBuild(os, build);
   }
 }
 
@@ -2334,7 +2371,7 @@
   std::string const& arg_dd, std::vector<std::string> const& arg_ddis,
   std::string const& module_dir,
   std::vector<std::string> const& linked_target_dirs,
-  std::string const& arg_lang)
+  std::string const& arg_lang, std::string const& arg_modmapfmt)
 {
   // Setup path conversions.
   {
@@ -2421,6 +2458,48 @@
         build.Variables.emplace("restat", "1");
       }
 
+      if (arg_modmapfmt.empty()) {
+        // nothing to do.
+      } else {
+        std::stringstream mm;
+        if (arg_modmapfmt == "gcc") {
+          // Documented in GCC's documentation. The format is a series of lines
+          // with a module name and the associated filename separated by
+          // spaces. The first line may use `$root` as the module name to
+          // specify a "repository root". That is used to anchor any relative
+          // paths present in the file (CMake should never generate any).
+
+          // Write the root directory to use for module paths.
+          mm << "$root .\n";
+
+          for (auto const& l : object.Provides) {
+            auto m = mod_files.find(l.LogicalName);
+            if (m != mod_files.end()) {
+              mm << l.LogicalName << " " << this->ConvertToNinjaPath(m->second)
+                 << "\n";
+            }
+          }
+          for (auto const& r : object.Requires) {
+            auto m = mod_files.find(r.LogicalName);
+            if (m != mod_files.end()) {
+              mm << r.LogicalName << " " << this->ConvertToNinjaPath(m->second)
+                 << "\n";
+            }
+          }
+        } else {
+          cmSystemTools::Error(
+            cmStrCat("-E cmake_ninja_dyndep does not understand the ",
+                     arg_modmapfmt, " module map format"));
+          return false;
+        }
+
+        // XXX(modmap): If changing this path construction, change
+        // `cmNinjaTargetGenerator::WriteObjectBuildStatements` to generate the
+        // corresponding file path.
+        cmGeneratedFileStream mmf(cmStrCat(object.PrimaryOutput, ".modmap"));
+        mmf << mm.str();
+      }
+
       this->WriteBuild(ddf, build);
     }
   }
@@ -2444,6 +2523,7 @@
   std::string arg_dd;
   std::string arg_lang;
   std::string arg_tdi;
+  std::string arg_modmapfmt;
   std::vector<std::string> arg_ddis;
   for (std::string const& arg : arg_full) {
     if (cmHasLiteralPrefix(arg, "--tdi=")) {
@@ -2452,6 +2532,8 @@
       arg_lang = arg.substr(7);
     } else if (cmHasLiteralPrefix(arg, "--dd=")) {
       arg_dd = arg.substr(5);
+    } else if (cmHasLiteralPrefix(arg, "--modmapfmt=")) {
+      arg_modmapfmt = arg.substr(12);
     } else if (!cmHasLiteralPrefix(arg, "--") &&
                cmHasLiteralSuffix(arg, ".ddi")) {
       arg_ddis.push_back(arg);
@@ -2510,7 +2592,7 @@
   if (!ggd ||
       !cm::static_reference_cast<cmGlobalNinjaGenerator>(ggd).WriteDyndepFile(
         dir_top_src, dir_top_bld, dir_cur_src, dir_cur_bld, arg_dd, arg_ddis,
-        module_dir, linked_target_dirs, arg_lang)) {
+        module_dir, linked_target_dirs, arg_lang, arg_modmapfmt)) {
     return 1;
   }
   return 0;
diff --git a/Source/cmGlobalNinjaGenerator.h b/Source/cmGlobalNinjaGenerator.h
index 5e9defe..fd8542f 100644
--- a/Source/cmGlobalNinjaGenerator.h
+++ b/Source/cmGlobalNinjaGenerator.h
@@ -150,7 +150,7 @@
   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 @@
     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);
@@ -393,15 +396,13 @@
   bool HasOutputPathPrefix() const { return !this->OutputPathPrefix.empty(); }
   void StripNinjaOutputPathPrefixAsSuffix(std::string& path);
 
-  bool WriteDyndepFile(std::string const& dir_top_src,
-                       std::string const& dir_top_bld,
-                       std::string const& dir_cur_src,
-                       std::string const& dir_cur_bld,
-                       std::string const& arg_dd,
-                       std::vector<std::string> const& arg_ddis,
-                       std::string const& module_dir,
-                       std::vector<std::string> const& linked_target_dirs,
-                       std::string const& arg_lang);
+  bool WriteDyndepFile(
+    std::string const& dir_top_src, std::string const& dir_top_bld,
+    std::string const& dir_cur_src, std::string const& dir_cur_bld,
+    std::string const& arg_dd, std::vector<std::string> const& arg_ddis,
+    std::string const& module_dir,
+    std::vector<std::string> const& linked_target_dirs,
+    std::string const& arg_lang, std::string const& arg_modmapfmt);
 
   virtual std::string BuildAlias(const std::string& alias,
                                  const std::string& /*config*/) const
@@ -445,6 +446,8 @@
 
   bool IsSingleConfigUtility(cmGeneratorTarget const* target) const;
 
+  bool CheckCxxModuleSupport();
+
 protected:
   void Generate() override;
 
@@ -565,6 +568,8 @@
   bool NinjaSupportsMultipleOutputs = false;
   bool NinjaSupportsMetadataOnRegeneration = false;
 
+  bool DiagnosedCxxModuleSupport = false;
+
 private:
   void InitOutputPathPrefix();
 
diff --git a/Source/cmGlobalUnixMakefileGenerator3.cxx b/Source/cmGlobalUnixMakefileGenerator3.cxx
index 11e2cd6..97384cd 100644
--- a/Source/cmGlobalUnixMakefileGenerator3.cxx
+++ b/Source/cmGlobalUnixMakefileGenerator3.cxx
@@ -838,7 +838,7 @@
     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/cmGlobalUnixMakefileGenerator3.h b/Source/cmGlobalUnixMakefileGenerator3.h
index 09679a7..c15f491 100644
--- a/Source/cmGlobalUnixMakefileGenerator3.h
+++ b/Source/cmGlobalUnixMakefileGenerator3.h
@@ -139,6 +139,12 @@
     return this->ToolSupportsCompilerDependencies;
   }
 
+  // Make tool supports long line dependencies
+  bool SupportsLongLineDependencies()
+  {
+    return this->ToolSupportsLongLineDependencies;
+  }
+
   /** Get the command to use for a target that has no rule.  This is
       used for multiple output dependencies and for cmake_force.  */
   std::string GetEmptyRuleHackCommand() { return this->EmptyRuleHackCommand; }
@@ -235,6 +241,10 @@
   // generated by the compiler
   bool ToolSupportsCompilerDependencies = true;
 
+  // some Make generator, such as Borland not support long line dependencies,
+  // we add SupportsLongLineDependencies to predicate.
+  bool ToolSupportsLongLineDependencies = true;
+
   // Some make programs (Borland) do not keep a rule if there are no
   // dependencies or commands.  This is a problem for creating rules
   // that might not do anything but might have other dependencies
diff --git a/Source/cmGlobalXCodeGenerator.cxx b/Source/cmGlobalXCodeGenerator.cxx
index d59d382..8a1ccd1 100644
--- a/Source/cmGlobalXCodeGenerator.cxx
+++ b/Source/cmGlobalXCodeGenerator.cxx
@@ -18,6 +18,7 @@
 #include "cmsys/RegularExpression.hxx"
 
 #include "cmComputeLinkInformation.h"
+#include "cmCryptoHash.h"
 #include "cmCustomCommand.h"
 #include "cmCustomCommandGenerator.h"
 #include "cmCustomCommandLines.h"
@@ -798,9 +799,10 @@
 }
 
 cmXCodeObject* cmGlobalXCodeGenerator::CreateObject(
-  cmXCodeObject::PBXType ptype)
+  cmXCodeObject::PBXType ptype, cm::string_view key)
 {
-  auto obj = cm::make_unique<cmXCode21Object>(ptype, cmXCodeObject::OBJECT);
+  auto obj = cm::make_unique<cmXCode21Object>(ptype, cmXCodeObject::OBJECT,
+                                              this->GetObjectId(ptype, key));
   auto ptr = obj.get();
   this->addObject(std::move(obj));
   return ptr;
@@ -808,7 +810,9 @@
 
 cmXCodeObject* cmGlobalXCodeGenerator::CreateObject(cmXCodeObject::Type type)
 {
-  auto obj = cm::make_unique<cmXCodeObject>(cmXCodeObject::None, type);
+  auto obj = cm::make_unique<cmXCodeObject>(
+    cmXCodeObject::None, type,
+    "Temporary cmake object, should not be referred to in Xcode file");
   auto ptr = obj.get();
   this->addObject(std::move(obj));
   return ptr;
@@ -1739,13 +1743,13 @@
   if (this->XcodeBuildSystem >= BuildSystem::Twelve) {
     // create prebuild phase
     preBuildPhase =
-      this->CreateRunScriptBuildPhase("CMake PreBuild Rules", prebuild);
+      this->CreateRunScriptBuildPhase("CMake PreBuild Rules", gtgt, prebuild);
     // create prelink phase
     preLinkPhase =
-      this->CreateRunScriptBuildPhase("CMake PreLink Rules", prelink);
+      this->CreateRunScriptBuildPhase("CMake PreLink Rules", gtgt, prelink);
     // create postbuild phase
-    postBuildPhase =
-      this->CreateRunScriptBuildPhase("CMake PostBuild Rules", postbuild);
+    postBuildPhase = this->CreateRunScriptBuildPhase("CMake PostBuild Rules",
+                                                     gtgt, postbuild);
   } else {
     std::vector<cmSourceFile*> classes;
     if (!gtgt->GetConfigCommonSourceFilesForXcode(classes)) {
@@ -1877,7 +1881,8 @@
   }
 
   cmXCodeObject* buildPhase =
-    this->CreateObject(cmXCodeObject::PBXShellScriptBuildPhase);
+    this->CreateObject(cmXCodeObject::PBXShellScriptBuildPhase,
+                       cmStrCat(gt->GetName(), ':', sf->GetFullPath()));
   buildPhase->AddAttribute("buildActionMask",
                            this->CreateString("2147483647"));
   cmXCodeObject* buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
@@ -1936,7 +1941,8 @@
 }
 
 cmXCodeObject* cmGlobalXCodeGenerator::CreateRunScriptBuildPhase(
-  std::string const& name, std::vector<cmCustomCommand> const& commands)
+  std::string const& name, cmGeneratorTarget const* gt,
+  std::vector<cmCustomCommand> const& commands)
 {
   if (commands.empty()) {
     return nullptr;
@@ -1959,7 +1965,8 @@
   }
 
   cmXCodeObject* buildPhase =
-    this->CreateObject(cmXCodeObject::PBXShellScriptBuildPhase);
+    this->CreateObject(cmXCodeObject::PBXShellScriptBuildPhase,
+                       cmStrCat(gt->GetName(), ':', name));
   buildPhase->AddAttribute("buildActionMask",
                            this->CreateString("2147483647"));
   cmXCodeObject* buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
@@ -2927,8 +2934,8 @@
 cmXCodeObject* cmGlobalXCodeGenerator::CreateUtilityTarget(
   cmGeneratorTarget* gtgt)
 {
-  cmXCodeObject* shellBuildPhase =
-    this->CreateObject(cmXCodeObject::PBXShellScriptBuildPhase);
+  cmXCodeObject* shellBuildPhase = this->CreateObject(
+    cmXCodeObject::PBXShellScriptBuildPhase, gtgt->GetName());
   shellBuildPhase->AddAttribute("buildActionMask",
                                 this->CreateString("2147483647"));
   cmXCodeObject* buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
@@ -3156,6 +3163,32 @@
   return i->second;
 }
 
+std::string cmGlobalXCodeGenerator::GetObjectId(cmXCodeObject::PBXType ptype,
+                                                cm::string_view key)
+{
+  std::string objectId;
+  if (!key.empty()) {
+    cmCryptoHash hash(cmCryptoHash::AlgoSHA256);
+    hash.Initialize();
+    hash.Append(&ptype, sizeof(ptype));
+    hash.Append(key);
+    objectId = cmSystemTools::UpperCase(hash.FinalizeHex().substr(0, 24));
+  } else {
+    char cUuid[40] = { 0 };
+    CFUUIDRef uuid = CFUUIDCreate(kCFAllocatorDefault);
+    CFStringRef s = CFUUIDCreateString(kCFAllocatorDefault, uuid);
+    CFStringGetCString(s, cUuid, sizeof(cUuid), kCFStringEncodingUTF8);
+    objectId = cUuid;
+    CFRelease(s);
+    CFRelease(uuid);
+    cmSystemTools::ReplaceString(objectId, "-", "");
+    if (objectId.size() > 24) {
+      objectId = objectId.substr(0, 24);
+    }
+  }
+  return objectId;
+}
+
 std::string cmGlobalXCodeGenerator::GetOrCreateId(const std::string& name,
                                                   const std::string& id)
 {
diff --git a/Source/cmGlobalXCodeGenerator.h b/Source/cmGlobalXCodeGenerator.h
index 14db1dc..1ab56e2 100644
--- a/Source/cmGlobalXCodeGenerator.h
+++ b/Source/cmGlobalXCodeGenerator.h
@@ -11,6 +11,8 @@
 #include <string>
 #include <vector>
 
+#include <cm/string_view>
+
 #include "cmGlobalGenerator.h"
 #include "cmXCodeObject.h"
 
@@ -162,11 +164,13 @@
                                  const std::string& configName);
 
   cmXCodeObject* FindXCodeTarget(const cmGeneratorTarget*);
+  std::string GetObjectId(cmXCodeObject::PBXType ptype, cm::string_view key);
   std::string GetOrCreateId(const std::string& name, const std::string& id);
 
   // create cmXCodeObject from these functions so that memory can be managed
   // correctly.  All objects created are stored in this->XCodeObjects.
-  cmXCodeObject* CreateObject(cmXCodeObject::PBXType ptype);
+  cmXCodeObject* CreateObject(cmXCodeObject::PBXType ptype,
+                              cm::string_view key = {});
   cmXCodeObject* CreateObject(cmXCodeObject::Type type);
   cmXCodeObject* CreateString(const std::string& s);
   cmXCodeObject* CreateObjectReference(cmXCodeObject*);
@@ -256,7 +260,8 @@
                                            cmGeneratorTarget const* gt,
                                            cmCustomCommand const& cc);
   cmXCodeObject* CreateRunScriptBuildPhase(
-    std::string const& name, std::vector<cmCustomCommand> const& commands);
+    std::string const& name, cmGeneratorTarget const* gt,
+    std::vector<cmCustomCommand> const& commands);
   std::string ConstructScript(cmCustomCommandGenerator const& ccg);
   void CreateReRunCMakeFile(cmLocalGenerator* root,
                             std::vector<cmLocalGenerator*> const& gens);
diff --git a/Source/cmGraphVizWriter.cxx b/Source/cmGraphVizWriter.cxx
index cf4ba93..92ffe29 100644
--- a/Source/cmGraphVizWriter.cxx
+++ b/Source/cmGraphVizWriter.cxx
@@ -131,8 +131,8 @@
 
 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 @@
     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 @@
   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 @@
   }
 
   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 @@
     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 @@
                                           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 @@
   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 @@
   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 175e7cf..0b45f28 100644
--- a/Source/cmInstallDirectoryGenerator.cxx
+++ b/Source/cmInstallDirectoryGenerator.cxx
@@ -27,7 +27,7 @@
   , 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 6e3508c..3683ada 100644
--- a/Source/cmInstallExportGenerator.cxx
+++ b/Source/cmInstallExportGenerator.cxx
@@ -122,10 +122,10 @@
 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 ad2f84e..0a353e4 100644
--- a/Source/cmInstallFilesGenerator.cxx
+++ b/Source/cmInstallFilesGenerator.cxx
@@ -25,8 +25,12 @@
   , Programs(programs)
   , Optional(optional)
 {
-  // We need per-config actions if the destination has generator expressions.
-  if (cmGeneratorExpression::Find(Destination) != std::string::npos) {
+  // We need per-config actions if the destination and rename have generator
+  // expressions.
+  if (cmGeneratorExpression::Find(this->Destination) != std::string::npos) {
+    this->ActionsPerConfig = true;
+  }
+  if (cmGeneratorExpression::Find(this->Rename) != std::string::npos) {
     this->ActionsPerConfig = true;
   }
 
@@ -56,6 +60,12 @@
                                          this->LocalGenerator, config);
 }
 
+std::string cmInstallFilesGenerator::GetRename(std::string const& config) const
+{
+  return cmGeneratorExpression::Evaluate(this->Rename, this->LocalGenerator,
+                                         config);
+}
+
 void cmInstallFilesGenerator::AddFilesInstallRule(
   std::ostream& os, std::string const& config, Indent indent,
   std::vector<std::string> const& files)
@@ -66,7 +76,7 @@
     os, this->GetDestination(config),
     (this->Programs ? cmInstallType_PROGRAMS : cmInstallType_FILES), files,
     this->Optional, this->FilePermissions.c_str(), no_dir_permissions,
-    this->Rename.c_str(), nullptr, indent);
+    this->GetRename(config).c_str(), nullptr, indent);
 }
 
 void cmInstallFilesGenerator::GenerateScriptActions(std::ostream& os,
diff --git a/Source/cmInstallFilesGenerator.h b/Source/cmInstallFilesGenerator.h
index b5a1ef4..66145f4 100644
--- a/Source/cmInstallFilesGenerator.h
+++ b/Source/cmInstallFilesGenerator.h
@@ -31,6 +31,7 @@
   bool Compute(cmLocalGenerator* lg) override;
 
   std::string GetDestination(std::string const& config) const;
+  std::string GetRename(std::string const& config) const;
 
 protected:
   void GenerateScriptActions(std::ostream& os, Indent indent) override;
diff --git a/Source/cmInstallScriptGenerator.cxx b/Source/cmInstallScriptGenerator.cxx
index 7cdf3b4..ce2472d 100644
--- a/Source/cmInstallScriptGenerator.cxx
+++ b/Source/cmInstallScriptGenerator.cxx
@@ -22,7 +22,7 @@
   , 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 d70176d..616bf7e 100644
--- a/Source/cmLinkedTree.h
+++ b/Source/cmLinkedTree.h
@@ -133,9 +133,9 @@
     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 a2c14bd..fdddb45 100644
--- a/Source/cmListCommand.cxx
+++ b/Source/cmListCommand.cxx
@@ -422,9 +422,10 @@
 bool HandleRemoveItemCommand(std::vector<std::string> const& args,
                              cmExecutionStatus& status)
 {
-  if (args.size() < 3) {
-    status.SetError("sub-command REMOVE_ITEM requires two or more arguments.");
-    return false;
+  assert(args.size() >= 2);
+
+  if (args.size() == 2) {
+    return true;
   }
 
   const std::string& listName = args[1];
@@ -609,9 +610,9 @@
 
   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 +751,7 @@
     {
     }
 
-    operator const std::string&() const { return Name; }
+    operator const std::string&() const { return this->Name; }
 
     std::string Name;
     int Arity = 0;
@@ -1093,8 +1094,9 @@
 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 +1104,7 @@
   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 +1114,13 @@
 
   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 +1426,7 @@
 
   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 3658d11..36a1372 100644
--- a/Source/cmListFileCache.cxx
+++ b/Source/cmListFileCache.cxx
@@ -105,7 +105,7 @@
     return false;
   }
 
-  return Parse();
+  return this->Parse();
 }
 
 bool cmListFileParser::ParseString(const char* str,
@@ -118,7 +118,7 @@
     return false;
   }
 
-  return Parse();
+  return this->Parse();
 }
 
 bool cmListFileParser::Parse()
diff --git a/Source/cmListFileCache.h b/Source/cmListFileCache.h
index ed45c07..98cb4a7 100644
--- a/Source/cmListFileCache.h
+++ b/Source/cmListFileCache.h
@@ -249,7 +249,7 @@
   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 b329e4b..86eddc2 100644
--- a/Source/cmLocalGenerator.cxx
+++ b/Source/cmLocalGenerator.cxx
@@ -2607,11 +2607,11 @@
                 }
 
                 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/cmLocalNinjaGenerator.cxx b/Source/cmLocalNinjaGenerator.cxx
index b035f70..7229101 100644
--- a/Source/cmLocalNinjaGenerator.cxx
+++ b/Source/cmLocalNinjaGenerator.cxx
@@ -557,9 +557,13 @@
   std::string launcher = this->MakeCustomLauncher(ccg);
 
   for (unsigned i = 0; i != ccg.GetNumberOfCommands(); ++i) {
+    std::string c = ccg.GetCommand(i);
+    if (c.empty()) {
+      continue;
+    }
     cmdLines.push_back(launcher +
                        this->ConvertToOutputFormat(
-                         ccg.GetCommand(i),
+                         c,
                          gg->IsMultiConfig() ? cmOutputConverter::NINJAMULTI
                                              : cmOutputConverter::SHELL));
 
@@ -689,13 +693,11 @@
   }
 }
 
-namespace {
-bool HasUniqueByproducts(cmLocalGenerator& lg,
-                         std::vector<std::string> const& byproducts,
-                         cmListFileBacktrace const& bt)
+bool cmLocalNinjaGenerator::HasUniqueByproducts(
+  std::vector<std::string> const& byproducts, cmListFileBacktrace const& bt)
 {
   std::vector<std::string> configs =
-    lg.GetMakefile()->GetGeneratorConfigs(cmMakefile::IncludeEmptyConfig);
+    this->GetMakefile()->GetGeneratorConfigs(cmMakefile::IncludeEmptyConfig);
   cmGeneratorExpression ge(bt);
   for (std::string const& p : byproducts) {
     if (cmGeneratorExpression::Find(p) == std::string::npos) {
@@ -705,7 +707,7 @@
     std::unique_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(p);
     for (std::string const& config : configs) {
       for (std::string const& b :
-           lg.ExpandCustomCommandOutputPaths(*cge, config)) {
+           this->ExpandCustomCommandOutputPaths(*cge, config)) {
         if (!seen.insert(b).second) {
           return false;
         }
@@ -715,6 +717,7 @@
   return true;
 }
 
+namespace {
 bool HasUniqueOutputs(std::vector<cmCustomCommandGenerator> const& ccgs)
 {
   std::set<std::string> allOutputs;
@@ -742,7 +745,7 @@
   // In Ninja Multi-Config, we can only produce cross-config utility
   // commands if all byproducts are per-config.
   if (!this->GetGlobalGenerator()->IsMultiConfig() ||
-      !HasUniqueByproducts(*this, byproducts, bt)) {
+      !this->HasUniqueByproducts(byproducts, bt)) {
     return this->cmLocalGenerator::CreateUtilityOutput(targetName, byproducts,
                                                        bt);
   }
diff --git a/Source/cmLocalNinjaGenerator.h b/Source/cmLocalNinjaGenerator.h
index 87d5e53..5b850f3 100644
--- a/Source/cmLocalNinjaGenerator.h
+++ b/Source/cmLocalNinjaGenerator.h
@@ -86,6 +86,9 @@
                                cmNinjaDeps& ninjaDeps,
                                const std::string& config);
 
+  bool HasUniqueByproducts(std::vector<std::string> const& byproducts,
+                           cmListFileBacktrace const& bt);
+
 protected:
   std::string ConvertToIncludeReference(
     std::string const& path,
diff --git a/Source/cmLocalUnixMakefileGenerator3.cxx b/Source/cmLocalUnixMakefileGenerator3.cxx
index 358df9d..df7952c 100644
--- a/Source/cmLocalUnixMakefileGenerator3.cxx
+++ b/Source/cmLocalUnixMakefileGenerator3.cxx
@@ -96,8 +96,8 @@
 
     // 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 74c9435..8cf3765 100644
--- a/Source/cmMSVC60LinkLineComputer.cxx
+++ b/Source/cmMSVC60LinkLineComputer.cxx
@@ -36,5 +36,5 @@
   }
 #endif
 
-  return cmLinkLineComputer::ConvertToLinkReference(lib);
+  return this->cmLinkLineComputer::ConvertToLinkReference(lib);
 }
diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx
index 9d37d61..cea20ad 100644
--- a/Source/cmMakefile.cxx
+++ b/Source/cmMakefile.cxx
@@ -303,7 +303,7 @@
 
   args.reserve(lff.Arguments().size());
   for (cmListFileArgument const& arg : lff.Arguments()) {
-    if (expand) {
+    if (expand && arg.Delim != cmListFileArgument::Bracket) {
       temp = arg.Value;
       this->ExpandVariablesInString(temp);
       args.push_back(temp);
@@ -978,7 +978,7 @@
     this->Backtrace = std::move(current);
   }
 
-  ~BacktraceGuard() { this->Backtrace = std::move(Previous); }
+  ~BacktraceGuard() { this->Backtrace = std::move(this->Previous); }
 
 private:
   cmListFileBacktrace& Backtrace;
@@ -1216,9 +1216,10 @@
   };
 
   // Each output must get its own copy of this rule.
-  cmsys::RegularExpression sourceFiles("\\.(C|M|c|c\\+\\+|cc|cpp|cxx|cu|m|mm|"
-                                       "rc|def|r|odl|idl|hpj|bat|h|h\\+\\+|"
-                                       "hm|hpp|hxx|in|txx|inl)$");
+  cmsys::RegularExpression sourceFiles(
+    "\\.(C|M|c|c\\+\\+|cc|cpp|cxx|mpp|cu|m|mm|"
+    "rc|def|r|odl|idl|hpj|bat|h|h\\+\\+|"
+    "hm|hpp|hxx|in|txx|inl)$");
 
   // Choose whether to use a main dependency.
   if (sourceFiles.find(source)) {
@@ -2438,7 +2439,7 @@
 
 bool cmMakefile::PlatformIsAppleEmbedded() const
 {
-  return GetAppleSDKType() != AppleSDK::MacOS;
+  return this->GetAppleSDKType() != AppleSDK::MacOS;
 }
 
 const char* cmMakefile::GetSONameFlag(const std::string& language) const
@@ -2449,7 +2450,7 @@
     name += language;
   }
   name += "_FLAG";
-  return cmToCStr(GetDefinition(name));
+  return cmToCStr(this->GetDefinition(name));
 }
 
 bool cmMakefile::CanIWriteThisFile(std::string const& fileName) const
@@ -2472,7 +2473,7 @@
   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 +2533,7 @@
 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 +2599,24 @@
       // 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 1617793..60b66a2 100644
--- a/Source/cmMakefile.h
+++ b/Source/cmMakefile.h
@@ -292,7 +292,7 @@
                           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 70a0393..adf40b0 100644
--- a/Source/cmMakefileTargetGenerator.cxx
+++ b/Source/cmMakefileTargetGenerator.cxx
@@ -71,7 +71,8 @@
       this->CMP0113New = true;
       break;
   }
-  MacOSXContentGenerator = cm::make_unique<MacOSXContentGeneratorType>(this);
+  this->MacOSXContentGenerator =
+    cm::make_unique<MacOSXContentGeneratorType>(this);
 }
 
 cmMakefileTargetGenerator::~cmMakefileTargetGenerator() = default;
@@ -344,27 +345,51 @@
              this->LocalGenerator->GetBinaryDirectory(), compilerDependFile))
       << "\n\n";
 
-    if (!cmSystemTools::FileExists(compilerDependFile)) {
-      // Write an empty dependency file.
-      cmGeneratedFileStream depFileStream(
-        compilerDependFile, false,
-        this->GlobalGenerator->GetMakefileEncoding());
-      depFileStream << "# Empty compiler generated dependencies file for "
-                    << this->GeneratorTarget->GetName() << ".\n"
-                    << "# This may be replaced when dependencies are built.\n";
-    }
+    // Write an empty dependency file.
+    cmGeneratedFileStream depFileStream(
+      compilerDependFile, false, this->GlobalGenerator->GetMakefileEncoding());
+    depFileStream << "# Empty compiler generated dependencies file for "
+                  << this->GeneratorTarget->GetName() << ".\n"
+                  << "# This may be replaced when dependencies are built.\n";
+    // remove internal dependency file
+    cmSystemTools::RemoveFile(
+      cmStrCat(this->TargetBuildDirectoryFull, "/compiler_depend.internal"));
 
     std::string compilerDependTimestamp =
       cmStrCat(this->TargetBuildDirectoryFull, "/compiler_depend.ts");
     if (!cmSystemTools::FileExists(compilerDependTimestamp)) {
       // Write a dependency timestamp file.
-      cmGeneratedFileStream depFileStream(
+      cmGeneratedFileStream timestampFileStream(
         compilerDependTimestamp, false,
         this->GlobalGenerator->GetMakefileEncoding());
-      depFileStream << "# CMAKE generated file: DO NOT EDIT!\n"
-                    << "# Timestamp file for compiler generated dependencies "
-                       "management for "
-                    << this->GeneratorTarget->GetName() << ".\n";
+      timestampFileStream
+        << "# CMAKE generated file: DO NOT EDIT!\n"
+        << "# Timestamp file for compiler generated dependencies "
+           "management for "
+        << this->GeneratorTarget->GetName() << ".\n";
+    }
+
+    // deactivate no longer needed legacy dependency files
+    // Write an empty dependency file.
+    cmGeneratedFileStream legacyDepFileStream(
+      dependFileNameFull, false, this->GlobalGenerator->GetMakefileEncoding());
+    legacyDepFileStream
+      << "# Empty dependencies file for " << this->GeneratorTarget->GetName()
+      << ".\n"
+      << "# This may be replaced when dependencies are built.\n";
+    // remove internal dependency file
+    cmSystemTools::RemoveFile(
+      cmStrCat(this->TargetBuildDirectoryFull, "/depend.internal"));
+  } else {
+    // make sure the depend file exists
+    if (!cmSystemTools::FileExists(dependFileNameFull)) {
+      // Write an empty dependency file.
+      cmGeneratedFileStream depFileStream(
+        dependFileNameFull, false,
+        this->GlobalGenerator->GetMakefileEncoding());
+      depFileStream << "# Empty dependencies file for "
+                    << this->GeneratorTarget->GetName() << ".\n"
+                    << "# This may be replaced when dependencies are built.\n";
     }
   }
 
@@ -380,16 +405,6 @@
       << "\n\n";
   }
 
-  // make sure the depend file exists
-  if (!cmSystemTools::FileExists(dependFileNameFull)) {
-    // Write an empty dependency file.
-    cmGeneratedFileStream depFileStream(
-      dependFileNameFull, false, this->GlobalGenerator->GetMakefileEncoding());
-    depFileStream << "# Empty dependencies file for "
-                  << this->GeneratorTarget->GetName() << ".\n"
-                  << "# This may be replaced when dependencies are built.\n";
-  }
-
   // Open the flags file.  This should be copy-if-different because the
   // rules may depend on this file itself.
   this->FlagFileNameFull =
@@ -854,6 +869,7 @@
     shellDependencyFile = this->LocalGenerator->ConvertToOutputFormat(
       depFile, cmOutputConverter::SHELL);
     vars.DependencyFile = shellDependencyFile.c_str();
+    this->CleanFiles.insert(depFile);
 
     dependencyTimestamp = this->LocalGenerator->MaybeConvertToRelativePath(
       this->LocalGenerator->GetBinaryDirectory(),
@@ -897,7 +913,7 @@
       cmExpandList(compileRule, compileCommands);
     }
 
-    if (this->Makefile->IsOn("CMAKE_EXPORT_COMPILE_COMMANDS") &&
+    if (this->GeneratorTarget->GetPropertyAsBool("EXPORT_COMPILE_COMMANDS") &&
         lang_can_export_cmds && compileCommands.size() == 1) {
       std::string compileCommand = compileCommands[0];
 
diff --git a/Source/cmNewLineStyle.cxx b/Source/cmNewLineStyle.cxx
index a121332..28baeb6 100644
--- a/Source/cmNewLineStyle.cxx
+++ b/Source/cmNewLineStyle.cxx
@@ -8,13 +8,13 @@
 
 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 @@
       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 @@
 
 std::string cmNewLineStyle::GetCharacters() const
 {
-  switch (NewLineStyle) {
+  switch (this->NewLineStyle) {
     case Invalid:
       return "";
     case LF:
@@ -56,10 +56,10 @@
 
 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 7fbeeea..2304ad2 100644
--- a/Source/cmNinjaLinkLineComputer.cxx
+++ b/Source/cmNinjaLinkLineComputer.cxx
@@ -18,5 +18,5 @@
 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 84c1b37..f66e2f5 100644
--- a/Source/cmNinjaLinkLineDeviceComputer.cxx
+++ b/Source/cmNinjaLinkLineDeviceComputer.cxx
@@ -16,5 +16,5 @@
 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 a5b9466..49e5e4c 100644
--- a/Source/cmNinjaNormalTargetGenerator.cxx
+++ b/Source/cmNinjaNormalTargetGenerator.cxx
@@ -12,6 +12,7 @@
 #include <utility>
 
 #include <cm/memory>
+#include <cm/optional>
 #include <cm/vector>
 
 #include "cmComputeLinkInformation.h"
@@ -49,7 +50,7 @@
     // 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 +307,7 @@
 {
   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 +335,13 @@
   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 +386,7 @@
 
     // 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 +674,7 @@
   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 +731,7 @@
              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 +745,7 @@
       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 +768,7 @@
                                          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 +788,7 @@
   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 +807,7 @@
            ->GetFullName(fileConfig, cmStateEnums::ImportLibraryArtifact)
            .empty() &&
         targetOutputImplib ==
-          ConvertToNinjaPath(genTarget->GetFullPath(
+          this->ConvertToNinjaPath(genTarget->GetFullPath(
             fileConfig, cmStateEnums::ImportLibraryArtifact))) {
       return;
     }
@@ -882,16 +883,16 @@
     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 +934,22 @@
   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 +957,7 @@
         !gt->GetFullName(fileConfig, cmStateEnums::ImportLibraryArtifact)
            .empty() &&
         targetOutputImplib ==
-          ConvertToNinjaPath(gt->GetFullPath(
+          this->ConvertToNinjaPath(gt->GetFullPath(
             fileConfig, cmStateEnums::ImportLibraryArtifact))) {
       return;
     }
@@ -1095,7 +1097,8 @@
   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 +1192,7 @@
     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 +1221,7 @@
     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"];
@@ -1236,22 +1239,25 @@
   std::vector<std::string> preLinkCmdLines;
   std::vector<std::string> postBuildCmdLines;
 
-  if (config == fileConfig) {
-    std::vector<std::string>* cmdLineLists[3] = { &preLinkCmdLines,
-                                                  &preLinkCmdLines,
-                                                  &postBuildCmdLines };
+  std::vector<std::string>* cmdLineLists[3] = { &preLinkCmdLines,
+                                                &preLinkCmdLines,
+                                                &postBuildCmdLines };
 
-    for (unsigned i = 0; i != 3; ++i) {
-      for (cmCustomCommand const& cc : *cmdLists[i]) {
-        cmCustomCommandGenerator ccg(cc, config, this->GetLocalGenerator());
+  for (unsigned i = 0; i != 3; ++i) {
+    for (cmCustomCommand const& cc : *cmdLists[i]) {
+      if (config == fileConfig ||
+          this->GetLocalGenerator()->HasUniqueByproducts(cc.GetByproducts(),
+                                                         cc.GetBacktrace())) {
+        cmCustomCommandGenerator ccg(cc, fileConfig, this->GetLocalGenerator(),
+                                     true, config);
         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 +1278,7 @@
     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 +1331,7 @@
   // 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 9075563..672b579 100644
--- a/Source/cmNinjaTargetGenerator.cxx
+++ b/Source/cmNinjaTargetGenerator.cxx
@@ -35,6 +35,7 @@
 #include "cmRange.h"
 #include "cmRulePlaceholderExpander.h"
 #include "cmSourceFile.h"
+#include "cmStandardLevelResolver.h"
 #include "cmState.h"
 #include "cmStateTypes.h"
 #include "cmStringAlgorithms.h"
@@ -146,9 +147,26 @@
     '_', config);
 }
 
-bool cmNinjaTargetGenerator::NeedDyndep(std::string const& lang) const
+bool cmNinjaTargetGenerator::NeedCxxModuleSupport(
+  std::string const& lang, std::string const& config) const
 {
-  return lang == "Fortran";
+  if (lang != "CXX") {
+    return false;
+  }
+  if (!this->Makefile->IsOn("CMAKE_EXPERIMENTAL_CXX_MODULE_DYNDEP")) {
+    return false;
+  }
+  cmGeneratorTarget const* tgt = this->GetGeneratorTarget();
+  cmStandardLevelResolver standardResolver(this->Makefile);
+  bool const uses_cxx20 =
+    standardResolver.HaveStandardAvailable(tgt, "CXX", config, "cxx_std_20");
+  return uses_cxx20 && this->GetGlobalGenerator()->CheckCxxModuleSupport();
+}
+
+bool cmNinjaTargetGenerator::NeedDyndep(std::string const& lang,
+                                        std::string const& config) const
+{
+  return lang == "Fortran" || this->NeedCxxModuleSupport(lang, config);
 }
 
 std::string cmNinjaTargetGenerator::OrderDependsTargetForTarget(
@@ -332,7 +350,8 @@
 
   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 +372,7 @@
   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 +380,7 @@
 std::string cmNinjaTargetGenerator::GetSourceFilePath(
   cmSourceFile const* source) const
 {
-  return ConvertToNinjaPath(source->GetFullPath());
+  return this->ConvertToNinjaPath(source->GetFullPath());
 }
 
 std::string cmNinjaTargetGenerator::GetObjectFilePath(
@@ -442,7 +461,7 @@
   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 +498,13 @@
     }
 
     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;
@@ -529,8 +548,9 @@
   scanVars.CMTargetName = vars.CMTargetName;
   scanVars.CMTargetType = vars.CMTargetType;
   scanVars.Language = vars.Language;
-  scanVars.Object = "$out"; // for RULE_LAUNCH_COMPILE
+  scanVars.Object = "$OBJ_FILE";
   scanVars.PreprocessedSource = "$out";
+  scanVars.DynDepFile = "$DYNDEP_INTERMEDIATE_FILE";
   scanVars.DependencyFile = rule.DepFile.c_str();
   scanVars.DependencyTarget = "$out";
 
@@ -585,7 +605,7 @@
   cmMakefile* mf = this->GetMakefile();
 
   // For some cases we scan to dynamically discover dependencies.
-  bool const needDyndep = this->NeedDyndep(lang);
+  bool const needDyndep = this->NeedDyndep(lang, config);
   bool const compilationPreprocesses = !this->NeedExplicitPreprocessing(lang);
 
   std::string flags = "$FLAGS";
@@ -600,12 +620,16 @@
       responseFlag = "@";
     }
   }
+  std::string const modmapFormatVar =
+    cmStrCat("CMAKE_EXPERIMENTAL_", lang, "_MODULE_MAP_FORMAT");
+  std::string const modmapFormat =
+    this->Makefile->GetSafeDefinition(modmapFormatVar);
 
   std::unique_ptr<cmRulePlaceholderExpander> rulePlaceholderExpander(
     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;
@@ -623,16 +647,26 @@
     // Rule to scan dependencies of sources that need preprocessing.
     {
       std::vector<std::string> scanCommands;
-      std::string const& scanRuleName =
-        this->LanguagePreprocessAndScanRule(lang, config);
-      std::string const& ppCommmand = mf->GetRequiredDefinition(
-        cmStrCat("CMAKE_", lang, "_PREPROCESS_SOURCE"));
-      cmExpandList(ppCommmand, scanCommands);
-      for (std::string& i : scanCommands) {
-        i = cmStrCat(launcher, i);
+      std::string scanRuleName;
+      if (compilationPreprocesses) {
+        scanRuleName = this->LanguageScanRule(lang, config);
+        std::string const& scanCommand = mf->GetRequiredDefinition(
+          cmStrCat("CMAKE_EXPERIMENTAL_", lang, "_SCANDEP_SOURCE"));
+        cmExpandList(scanCommand, scanCommands);
+        for (std::string& i : scanCommands) {
+          i = cmStrCat(launcher, i);
+        }
+      } else {
+        scanRuleName = this->LanguagePreprocessAndScanRule(lang, config);
+        std::string const& ppCommmand = mf->GetRequiredDefinition(
+          cmStrCat("CMAKE_", lang, "_PREPROCESS_SOURCE"));
+        cmExpandList(ppCommmand, scanCommands);
+        for (std::string& i : scanCommands) {
+          i = cmStrCat(launcher, i);
+        }
+        scanCommands.emplace_back(GetScanCommand(cmakeCmd, tdi, lang, "$out",
+                                                 "$DYNDEP_INTERMEDIATE_FILE"));
       }
-      scanCommands.emplace_back(GetScanCommand(cmakeCmd, tdi, lang, "$out",
-                                               "$DYNDEP_INTERMEDIATE_FILE"));
 
       auto scanRule = GetScanRule(
         scanRuleName, vars, responseFlag, flags, rulePlaceholderExpander.get(),
@@ -640,12 +674,18 @@
 
       scanRule.Comment =
         cmStrCat("Rule for generating ", lang, " dependencies.");
-      scanRule.Description = cmStrCat("Building ", lang, " preprocessed $out");
+      if (compilationPreprocesses) {
+        scanRule.Description =
+          cmStrCat("Scanning $in for ", lang, " dependencies");
+      } else {
+        scanRule.Description =
+          cmStrCat("Building ", lang, " preprocessed $out");
+      }
 
       this->GetGlobalGenerator()->AddRule(scanRule);
     }
 
-    {
+    if (!compilationPreprocesses) {
       // Compilation will not preprocess, so it does not need the defines
       // unless the compiler wants them for some other purpose.
       if (!this->CompileWithDefines(lang)) {
@@ -680,12 +720,16 @@
 
     // Run CMake dependency scanner on the source file (using the preprocessed
     // source if that was performed).
+    std::string ddModmapArg;
+    if (!modmapFormat.empty()) {
+      ddModmapArg += cmStrCat(" --modmapfmt=", modmapFormat);
+    }
     {
       std::vector<std::string> ddCmds;
       {
-        std::string ccmd =
-          cmStrCat(cmakeCmd, " -E cmake_ninja_dyndep --tdi=", tdi,
-                   " --lang=", lang, " --dd=$out @", rule.RspFile);
+        std::string ccmd = cmStrCat(
+          cmakeCmd, " -E cmake_ninja_dyndep --tdi=", tdi, " --lang=", lang,
+          ddModmapArg, " --dd=$out @", rule.RspFile);
         ddCmds.emplace_back(std::move(ccmd));
       }
       rule.Command = this->GetLocalGenerator()->BuildCommandLine(ddCmds);
@@ -747,6 +791,14 @@
     }
   }
 
+  if (needDyndep && !modmapFormat.empty()) {
+    std::string modmapFlags = mf->GetRequiredDefinition(
+      cmStrCat("CMAKE_EXPERIMENTAL_", lang, "_MODULE_MAP_FLAG"));
+    cmSystemTools::ReplaceString(modmapFlags, "<MODULE_MAP_FILE>",
+                                 "$DYNDEP_MODULE_MAP_FILE");
+    flags += cmStrCat(' ', modmapFlags);
+  }
+
   vars.Flags = flags.c_str();
   vars.DependencyFile = rule.DepFile.c_str();
 
@@ -922,7 +974,8 @@
       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 +1009,11 @@
       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());
@@ -1049,6 +1104,7 @@
                                    const std::string& ppFileName,
                                    bool compilePP, bool compilePPWithDefines,
                                    cmNinjaBuild& objBuild, cmNinjaVars& vars,
+                                   std::string const& modmapFormat,
                                    const std::string& objectFileName,
                                    cmLocalGenerator* lg)
 {
@@ -1119,6 +1175,15 @@
     vars.erase("DEP_FILE");
   }
 
+  if (!modmapFormat.empty()) {
+    // XXX(modmap): If changing this path construction, change
+    // `cmGlobalNinjaGenerator::WriteDyndep` to expect the corresponding
+    // file path.
+    std::string const ddModmapFile = cmStrCat(objectFileName, ".modmap");
+    scanBuild.Variables["DYNDEP_MODULE_MAP_FILE"] = ddModmapFile;
+    scanBuild.ImplicitOuts.push_back(ddModmapFile);
+  }
+
   return scanBuild;
 }
 }
@@ -1143,7 +1208,7 @@
   // 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 +1305,7 @@
     }
     std::transform(depList.begin(), depList.end(),
                    std::back_inserter(objBuild.ImplicitDeps),
-                   MapToNinjaPath());
+                   this->MapToNinjaPath());
   }
 
   objBuild.OrderOnlyDeps.push_back(this->OrderDependsTargetForTarget(config));
@@ -1258,10 +1323,17 @@
   }
 
   // For some cases we scan to dynamically discover dependencies.
-  bool const needDyndep = this->NeedDyndep(language);
+  bool const needDyndep = this->NeedDyndep(language, config);
   bool const compilationPreprocesses =
     !this->NeedExplicitPreprocessing(language);
 
+  std::string modmapFormat;
+  if (needDyndep) {
+    std::string const modmapFormatVar =
+      cmStrCat("CMAKE_EXPERIMENTAL_", language, "_MODULE_MAP_FORMAT");
+    modmapFormat = this->Makefile->GetSafeDefinition(modmapFormatVar);
+  }
+
   if (needDyndep) {
     // If source/target has preprocessing turned off, we still need to
     // generate an explicit dependency step
@@ -1291,7 +1363,7 @@
 
     cmNinjaBuild ppBuild = GetScanBuildStatement(
       scanRuleName, ppFileName, compilePP, compilePPWithDefines, objBuild,
-      vars, objectFileName, this->LocalGenerator);
+      vars, modmapFormat, objectFileName, this->LocalGenerator);
 
     if (compilePP) {
       // In case compilation requires flags that are incompatible with
@@ -1327,9 +1399,15 @@
     std::string const dyndep = this->GetDyndepFilePath(language, config);
     objBuild.OrderOnlyDeps.push_back(dyndep);
     vars["dyndep"] = dyndep;
+
+    if (!modmapFormat.empty()) {
+      std::string const ddModmapFile = cmStrCat(objectFileName, ".modmap");
+      vars["DYNDEP_MODULE_MAP_FILE"] = ddModmapFile;
+      objBuild.OrderOnlyDeps.push_back(ddModmapFile);
+    }
   }
 
-  EnsureParentDirectoryExists(objectFileName);
+  this->EnsureParentDirectoryExists(objectFileName);
 
   vars["OBJECT_DIR"] = this->GetLocalGenerator()->ConvertToOutputFormat(
     objectDir, cmOutputConverter::SHELL);
@@ -1402,7 +1480,7 @@
     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 +1502,7 @@
       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);
@@ -1440,17 +1518,26 @@
   tdi["compiler-id"] = this->Makefile->GetSafeDefinition(
     cmStrCat("CMAKE_", lang, "_COMPILER_ID"));
 
+  std::string mod_dir;
   if (lang == "Fortran") {
-    std::string mod_dir = this->GeneratorTarget->GetFortranModuleDirectory(
+    mod_dir = this->GeneratorTarget->GetFortranModuleDirectory(
       this->Makefile->GetHomeOutputDirectory());
-    if (mod_dir.empty()) {
-      mod_dir = this->Makefile->GetCurrentBinaryDirectory();
-    }
-    tdi["module-dir"] = mod_dir;
+  } else if (lang == "CXX") {
+    mod_dir =
+      cmSystemTools::CollapseFullPath(this->GeneratorTarget->ObjectDirectory);
+  }
+  if (mod_dir.empty()) {
+    mod_dir = this->Makefile->GetCurrentBinaryDirectory();
+  }
+  tdi["module-dir"] = mod_dir;
+
+  if (lang == "Fortran") {
     tdi["submodule-sep"] =
       this->Makefile->GetSafeDefinition("CMAKE_Fortran_SUBMODULE_SEP");
     tdi["submodule-ext"] =
       this->Makefile->GetSafeDefinition("CMAKE_Fortran_SUBMODULE_EXT");
+  } else if (lang == "CXX") {
+    // No extra information necessary.
   }
 
   tdi["dir-cur-bld"] = this->Makefile->GetCurrentBinaryDirectory();
@@ -1532,7 +1619,7 @@
   std::string const& objectFileDir, std::string const& flags,
   std::string const& defines, std::string const& includes)
 {
-  if (!this->Makefile->IsOn("CMAKE_EXPORT_COMPILE_COMMANDS")) {
+  if (!this->GeneratorTarget->GetPropertyAsBool("EXPORT_COMPILE_COMMANDS")) {
     return;
   }
 
@@ -1644,7 +1731,7 @@
 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/cmNinjaTargetGenerator.h b/Source/cmNinjaTargetGenerator.h
index 83a4342..79dc622 100644
--- a/Source/cmNinjaTargetGenerator.h
+++ b/Source/cmNinjaTargetGenerator.h
@@ -71,9 +71,11 @@
                                const std::string& config) const;
   std::string LanguageDyndepRule(std::string const& lang,
                                  const std::string& config) const;
-  bool NeedDyndep(std::string const& lang) const;
+  bool NeedDyndep(std::string const& lang, std::string const& config) const;
   bool NeedExplicitPreprocessing(std::string const& lang) const;
   bool CompileWithDefines(std::string const& lang) const;
+  bool NeedCxxModuleSupport(std::string const& lang,
+                            std::string const& config) const;
 
   std::string OrderDependsTargetForTarget(const std::string& config);
 
diff --git a/Source/cmNinjaUtilityTargetGenerator.cxx b/Source/cmNinjaUtilityTargetGenerator.cxx
index 0b62e16..3995624 100644
--- a/Source/cmNinjaUtilityTargetGenerator.cxx
+++ b/Source/cmNinjaUtilityTargetGenerator.cxx
@@ -83,7 +83,8 @@
         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 @@
         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 0fb4ff7..2d2676e 100644
--- a/Source/cmProcessOutput.cxx
+++ b/Source/cmProcessOutput.cxx
@@ -126,7 +126,7 @@
 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 @@
 {
   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 f22f36d..06e151a 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 @@
   }
 
   {
-    std::string& pVal = Map_[name];
+    std::string& pVal = this->Map_[name];
     if (!pVal.empty() && !asString) {
       pVal += ';';
     }
@@ -39,13 +39,13 @@
 
 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 @@
 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 @@
 {
   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 2db1b84..e12a653 100644
--- a/Source/cmQtAutoGen.h
+++ b/Source/cmQtAutoGen.h
@@ -111,20 +111,20 @@
     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 ff6fcd0..62b879f 100644
--- a/Source/cmQtAutoGenGlobalInitializer.cxx
+++ b/Source/cmQtAutoGenGlobalInitializer.cxx
@@ -57,7 +57,8 @@
         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 @@
         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 @@
         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 @@
         }
         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::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::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 @@
 
 bool cmQtAutoGenGlobalInitializer::generate()
 {
-  return (InitializeCustomTargets() && SetupCustomTargets());
+  return (this->InitializeCustomTargets() && this->SetupCustomTargets());
 }
 
 bool cmQtAutoGenGlobalInitializer::InitializeCustomTargets()
@@ -266,19 +269,19 @@
   // 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::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 cdae137..ea3821d 100644
--- a/Source/cmQtAutoGenGlobalInitializer.h
+++ b/Source/cmQtAutoGenGlobalInitializer.h
@@ -50,7 +50,7 @@
     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 1f74578..bfe174c 100644
--- a/Source/cmQtAutoGenInitializer.cxx
+++ b/Source/cmQtAutoGenInitializer.cxx
@@ -152,7 +152,8 @@
   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 @@
   // -- 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 @@
 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 @@
 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 @@
   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 @@
 
   Json::StyledStreamWriter jsonWriter;
   try {
-    jsonWriter.write(fileStream, Value_);
+    jsonWriter.write(fileStream, this->Value_);
   } catch (...) {
     return false;
   }
@@ -306,11 +310,11 @@
   , 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 @@
     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 @@
   // 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 @@
         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 @@
   }
 
   // Init rcc specific settings
-  if (this->Rcc.Enabled && !InitRcc()) {
+  if (this->Rcc.Enabled && !this->InitRcc()) {
     return false;
   }
 
@@ -572,8 +576,9 @@
       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 @@
                                      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 @@
                                         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 @@
       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 ee2bc09..ebb6bd7 100644
--- a/Source/cmQtAutoGenerator.cxx
+++ b/Source/cmQtAutoGenerator.cxx
@@ -18,10 +18,10 @@
     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 @@
     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::SetColorOutput(bool value)
 {
-  ColorOutput_ = value;
+  this->ColorOutput_ = value;
 }
 
 std::string cmQtAutoGenerator::Logger::HeadLine(cm::string_view title)
@@ -61,7 +61,7 @@
   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 @@
                    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 @@
     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 @@
   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 @@
 bool cmQtAutoGenerator::InfoT::Read(std::istream& istr)
 {
   try {
-    istr >> Json_;
+    istr >> this->Json_;
   } catch (...) {
     return false;
   }
@@ -264,22 +264,22 @@
 
 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 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 @@
                                        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 @@
                                         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 @@
                                         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 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::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 @@
 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 @@
 
     // 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 @@
       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 b4f057d..53fbd69 100644
--- a/Source/cmQtAutoGenerator.h
+++ b/Source/cmQtAutoGenerator.h
@@ -88,10 +88,10 @@
   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 @@
 
     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 @@
                                   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 @@
   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 c9d4268..3556051 100644
--- a/Source/cmQtAutoMocUic.cxx
+++ b/Source/cmQtAutoMocUic.cxx
@@ -313,22 +313,22 @@
     //! 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;
@@ -522,6 +522,7 @@
   class JobDepFilesMergeT : public JobFenceT
   {
   private:
+    std::vector<std::string> initialDependencies() const;
     void Process() override;
   };
 
@@ -541,9 +542,9 @@
   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 +598,19 @@
   , 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 +618,15 @@
 {
   // 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 +656,7 @@
     }
     // Check if this a file name line
     if (line.front() != ' ') {
-      fileHandle = GetOrInsert(line).first;
+      fileHandle = this->GetOrInsert(line).first;
       continue;
     }
 
@@ -702,7 +703,7 @@
     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 +733,7 @@
 
 cmQtAutoMocUicT::MocSettingsT::MocSettingsT()
 {
-  RegExpInclude.compile(
+  this->RegExpInclude.compile(
     "(^|\n)[ \t]*#[ \t]*include[ \t]+"
     "[\"<](([^ \">]+/)?moc_[^ \">/]+\\.cpp|[^ \">]+\\.moc)[\">]");
 }
@@ -741,14 +742,15 @@
 
 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 +770,31 @@
 
 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 +803,48 @@
                                        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 +852,31 @@
     // (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 +884,20 @@
 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 +905,14 @@
 
   // 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 +925,27 @@
 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 +966,16 @@
 
 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 +983,20 @@
 
 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 +1011,7 @@
 
   // 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 +1025,15 @@
 
 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 +1051,21 @@
       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 +1073,40 @@
       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 +1114,9 @@
 {
   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 +1125,14 @@
 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 +1152,16 @@
     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 +1183,7 @@
     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 +1205,13 @@
   // 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 +1220,16 @@
     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 +1243,31 @@
       // 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 +1280,7 @@
       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 +1290,54 @@
       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 +1348,27 @@
       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 +1382,7 @@
   cm::string_view includeBase)
 {
   // Clear search locations
-  SearchLocations.clear();
+  this->SearchLocations.clear();
 
   auto findHeader = [this,
                      &headerHandle](std::string const& basePath) -> bool {
@@ -1377,8 +1398,8 @@
 
       // 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 +1408,8 @@
 
       // 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 +1432,7 @@
     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 +1446,24 @@
   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 +1482,10 @@
   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 +1493,8 @@
   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 +1511,24 @@
 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 +1546,24 @@
   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 +1575,7 @@
   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 +1597,25 @@
   };
 
   // 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 +1628,26 @@
 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 +1662,8 @@
     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 +1673,42 @@
 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 +1718,23 @@
                                                  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 +1750,19 @@
   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 +1770,32 @@
   // 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 +1809,26 @@
       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 +1844,7 @@
 {
   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 +1859,7 @@
     }
   }
   // 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 +1871,22 @@
 
 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 +1900,19 @@
   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 +1920,19 @@
   // 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 +1948,64 @@
     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 +2025,8 @@
       }
     }
     // 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 +2038,60 @@
 
   // 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 +2100,25 @@
   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 +2128,41 @@
   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."));
     }
   }
 }
@@ -2169,12 +2199,36 @@
   return escapedPath;
 }
 
+/*
+ * Return the initial dependencies of the merged depfile.
+ * Those are dependencies from the project files, not from moc runs.
+ */
+std::vector<std::string>
+cmQtAutoMocUicT::JobDepFilesMergeT::initialDependencies() const
+{
+  std::vector<std::string> dependencies;
+  dependencies.reserve(this->BaseConst().ListFiles.size() +
+                       this->BaseEval().Headers.size() +
+                       this->BaseEval().Sources.size());
+  cm::append(dependencies, this->BaseConst().ListFiles);
+  auto append_file_path =
+    [&dependencies](const SourceFileMapT::value_type& p) {
+      dependencies.push_back(p.first);
+    };
+  std::for_each(this->BaseEval().Headers.begin(),
+                this->BaseEval().Headers.end(), append_file_path);
+  std::for_each(this->BaseEval().Sources.begin(),
+                this->BaseEval().Sources.end(), append_file_path);
+  return dependencies;
+}
+
 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 +2239,8 @@
     return dependenciesFromDepFile(f.c_str());
   };
 
-  std::vector<std::string> dependencies = BaseConst().ListFiles;
-  ParseCacheT& parseCache = BaseEval().ParseCache;
+  std::vector<std::string> dependencies = this->initialDependencies();
+  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 +2251,10 @@
                         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 +2262,42 @@
                      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 +2309,51 @@
 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", 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.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.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 +2363,21 @@
     } 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", 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.GetArrayConfig("MOC_INCLUDES", this->MocConst_.IncludePaths,
+                             false) ||
+        !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 +2385,12 @@
 
     // -- 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 +2440,23 @@
       }
     }
     // 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 +2490,17 @@
           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 +2575,15 @@
       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 +2654,19 @@
       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 +2677,25 @@
         }
       }
       // 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 +2706,16 @@
 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 +2723,56 @@
 /** 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 +2788,72 @@
       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 +2862,11 @@
 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 +2877,18 @@
           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 +2899,46 @@
 {
   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 (this->BaseEval().ParseCacheChanged) {
+    if (this->Log().Verbose()) {
+      this->Log().Info(
+        GenT::GEN,
+        cmStrCat("Writing the parse cache file ",
+                 this->MessagePath(this->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().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 +2948,12 @@
 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 +2975,21 @@
 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 08eb4b5..943cc93 100644
--- a/Source/cmQtAutoRcc.cxx
+++ b/Source/cmQtAutoRcc.cxx
@@ -35,7 +35,7 @@
 
 private:
   // -- Utility
-  bool IsMultiConfig() const { return MultiConfig_; }
+  bool IsMultiConfig() const { return this->MultiConfig_; }
   std::string MultiConfigOutput() const;
 
   // -- Abstract processing interface
@@ -93,38 +93,41 @@
 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::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 @@
       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 @@
   // 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 @@
   // 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::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::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::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::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::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::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/cmRulePlaceholderExpander.cxx b/Source/cmRulePlaceholderExpander.cxx
index 5363fef..d00bbdf 100644
--- a/Source/cmRulePlaceholderExpander.cxx
+++ b/Source/cmRulePlaceholderExpander.cxx
@@ -44,6 +44,11 @@
       return replaceValues.Source;
     }
   }
+  if (replaceValues.DynDepFile) {
+    if (variable == "DYNDEP_FILE") {
+      return replaceValues.DynDepFile;
+    }
+  }
   if (replaceValues.PreprocessedSource) {
     if (variable == "PREPROCESSED_SOURCE") {
       return replaceValues.PreprocessedSource;
diff --git a/Source/cmRulePlaceholderExpander.h b/Source/cmRulePlaceholderExpander.h
index 710f8a6..f8dc368 100644
--- a/Source/cmRulePlaceholderExpander.h
+++ b/Source/cmRulePlaceholderExpander.h
@@ -41,6 +41,7 @@
     const char* Source = nullptr;
     const char* AssemblySource = nullptr;
     const char* PreprocessedSource = nullptr;
+    const char* DynDepFile = nullptr;
     const char* Output = nullptr;
     const char* Object = nullptr;
     const char* ObjectDir = nullptr;
diff --git a/Source/cmScanDepFormat.cxx b/Source/cmScanDepFormat.cxx
index 40bf4c9..e046069 100644
--- a/Source/cmScanDepFormat.cxx
+++ b/Source/cmScanDepFormat.cxx
@@ -55,9 +55,8 @@
 #define PARSE_BLOB(val, res)                                                  \
   do {                                                                        \
     if (!ParseFilename(val, res)) {                                           \
-      cmSystemTools::Error(                                                   \
-        cmStrCat("-E cmake_ninja_depends failed to parse ", arg_pp,           \
-                 ": invalid blob"));                                          \
+      cmSystemTools::Error(cmStrCat("-E cmake_ninja_dyndep failed to parse ", \
+                                    arg_pp, ": invalid blob"));               \
       return false;                                                           \
     }                                                                         \
   } while (0)
@@ -65,9 +64,8 @@
 #define PARSE_FILENAME(val, res)                                              \
   do {                                                                        \
     if (!ParseFilename(val, res)) {                                           \
-      cmSystemTools::Error(                                                   \
-        cmStrCat("-E cmake_ninja_depends failed to parse ", arg_pp,           \
-                 ": invalid filename"));                                      \
+      cmSystemTools::Error(cmStrCat("-E cmake_ninja_dyndep failed to parse ", \
+                                    arg_pp, ": invalid filename"));           \
       return false;                                                           \
     }                                                                         \
                                                                               \
@@ -84,7 +82,7 @@
   {
     Json::Reader reader;
     if (!reader.parse(ppf, ppio, false)) {
-      cmSystemTools::Error(cmStrCat("-E cmake_ninja_depends failed to parse ",
+      cmSystemTools::Error(cmStrCat("-E cmake_ninja_dyndep failed to parse ",
                                     arg_pp,
                                     reader.getFormattedErrorMessages()));
       return false;
@@ -93,7 +91,7 @@
 
   Json::Value const& version = ppi["version"];
   if (version.asUInt() != 0) {
-    cmSystemTools::Error(cmStrCat("-E cmake_ninja_depends failed to parse ",
+    cmSystemTools::Error(cmStrCat("-E cmake_ninja_dyndep failed to parse ",
                                   arg_pp, ": version ", version.asString()));
     return false;
   }
@@ -101,7 +99,7 @@
   Json::Value const& rules = ppi["rules"];
   if (rules.isArray()) {
     if (rules.size() != 1) {
-      cmSystemTools::Error(cmStrCat("-E cmake_ninja_depends failed to parse ",
+      cmSystemTools::Error(cmStrCat("-E cmake_ninja_dyndep failed to parse ",
                                     arg_pp, ": expected 1 source entry"));
       return false;
     }
@@ -109,9 +107,9 @@
     for (auto const& rule : rules) {
       Json::Value const& workdir = rule["work-directory"];
       if (!workdir.isString()) {
-        cmSystemTools::Error(
-          cmStrCat("-E cmake_ninja_depends failed to parse ", arg_pp,
-                   ": work-directory is not a string"));
+        cmSystemTools::Error(cmStrCat("-E cmake_ninja_dyndep failed to parse ",
+                                      arg_pp,
+                                      ": work-directory is not a string"));
         return false;
       }
       std::string work_directory;
@@ -134,7 +132,7 @@
           if (outputs.isArray()) {
             if (outputs.empty()) {
               cmSystemTools::Error(
-                cmStrCat("-E cmake_ninja_depends failed to parse ", arg_pp,
+                cmStrCat("-E cmake_ninja_dyndep failed to parse ", arg_pp,
                          ": expected at least one 1 output"));
               return false;
             }
diff --git a/Source/cmSourceFile.h b/Source/cmSourceFile.h
index 94b5cc8..76a5ded 100644
--- a/Source/cmSourceFile.h
+++ b/Source/cmSourceFile.h
@@ -175,7 +175,7 @@
 #define CM_HEADER_REGEX "\\.(h|hh|h\\+\\+|hm|hpp|hxx|in|txx|inl)$"
 
 #define CM_SOURCE_REGEX                                                       \
-  "\\.(C|F|M|c|c\\+\\+|cc|cpp|cxx|cu|f|f90|for|fpp|ftn|m|mm|"                 \
+  "\\.(C|F|M|c|c\\+\\+|cc|cpp|mpp|cxx|cu|f|f90|for|fpp|ftn|m|mm|"             \
   "rc|def|r|odl|idl|hpj|bat)$"
 
 #define CM_PCH_REGEX "cmake_pch(_[^.]+)?\\.(h|hxx)$"
diff --git a/Source/cmStandardLevelResolver.cxx b/Source/cmStandardLevelResolver.cxx
index 5d8ccf1..bf6925e 100644
--- a/Source/cmStandardLevelResolver.cxx
+++ b/Source/cmStandardLevelResolver.cxx
@@ -44,6 +44,16 @@
   int value;
 };
 
+int ParseStd(std::string const& level)
+{
+  try {
+    return std::stoi(level);
+  } catch (std::invalid_argument&) {
+    // Fall through to use an invalid value.
+  }
+  return -1;
+}
+
 struct StanardLevelComputer
 {
   explicit StanardLevelComputer(std::string lang, std::vector<int> levels,
@@ -113,17 +123,8 @@
       standardStr = "03";
     }
 
-    int standardValue = -1;
-    int defaultValue = -1;
-    try {
-      standardValue = std::stoi(standardStr);
-      defaultValue = std::stoi(*defaultStd);
-    } catch (std::invalid_argument&) {
-      // fall through as we want an error
-      // when we can't find the bad value in the `stds` vector
-    }
-
-    auto stdIt = std::find(cm::cbegin(stds), cm::cend(stds), standardValue);
+    auto stdIt =
+      std::find(cm::cbegin(stds), cm::cend(stds), ParseStd(standardStr));
     if (stdIt == cm::cend(stds)) {
       std::string e =
         cmStrCat(this->Language, "_STANDARD is set to invalid value '",
@@ -134,7 +135,7 @@
     }
 
     auto defaultStdIt =
-      std::find(cm::cbegin(stds), cm::cend(stds), defaultValue);
+      std::find(cm::cbegin(stds), cm::cend(stds), ParseStd(*defaultStd));
     if (defaultStdIt == cm::cend(stds)) {
       std::string e = cmStrCat("CMAKE_", this->Language,
                                "_STANDARD_DEFAULT is set to invalid value '",
@@ -195,7 +196,7 @@
     if (existingStandard) {
       existingLevelIter =
         std::find(cm::cbegin(this->Levels), cm::cend(this->Levels),
-                  std::stoi(*existingStandard));
+                  ParseStd(*existingStandard));
       if (existingLevelIter == cm::cend(this->Levels)) {
         const std::string e =
           cmStrCat("The ", this->Language, "_STANDARD property on target \"",
@@ -240,7 +241,7 @@
     }
     // convert defaultStandard to an integer
     if (std::find(cm::cbegin(this->Levels), cm::cend(this->Levels),
-                  std::stoi(*defaultStandard)) == cm::cend(this->Levels)) {
+                  ParseStd(*defaultStandard)) == cm::cend(this->Levels)) {
       const std::string e = cmStrCat("The CMAKE_", this->Language,
                                      "_STANDARD_DEFAULT variable contains an "
                                      "invalid value: \"",
@@ -257,7 +258,7 @@
 
     auto existingLevelIter =
       std::find(cm::cbegin(this->Levels), cm::cend(this->Levels),
-                std::stoi(*existingStandard));
+                ParseStd(*existingStandard));
     if (existingLevelIter == cm::cend(this->Levels)) {
       const std::string e =
         cmStrCat("The ", this->Language, "_STANDARD property on target \"",
diff --git a/Source/cmState.cxx b/Source/cmState.cxx
index 3692a01..0fd7901 100644
--- a/Source/cmState.cxx
+++ b/Source/cmState.cxx
@@ -524,7 +524,7 @@
 
 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 796bb1f..7ce362a 100644
--- a/Source/cmStateDirectory.cxx
+++ b/Source/cmStateDirectory.cxx
@@ -148,11 +148,13 @@
             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 898b828..8721242 100644
--- a/Source/cmString.cxx
+++ b/Source/cmString.cxx
@@ -19,17 +19,17 @@
   // 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 @@
 
 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 (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 @@
   // 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(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 b41b960..f1e462b 100644
--- a/Source/cmString.hxx
+++ b/Source/cmString.hxx
@@ -301,8 +301,8 @@
       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 @@
   }
 
   /** 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 @@
       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 @@
   {
     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 @@
   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 @@
                   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 @@
   {
     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 @@
   {
     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 @@
 
   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 @@
   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 @@
     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 @@
     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 @@
   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 @@
   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 @@
   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 @@
   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 @@
   }
 #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 @@
 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 e0af281..fb0b705 100644
--- a/Source/cmStringAlgorithms.cxx
+++ b/Source/cmStringAlgorithms.cxx
@@ -161,42 +161,42 @@
 
 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 01e3d94..6b458ec 100644
--- a/Source/cmStringAlgorithms.h
+++ b/Source/cmStringAlgorithms.h
@@ -48,7 +48,7 @@
   {
   }
 
-  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 @@
   {
   }
   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 @@
   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 b28fca9..0c8adc7 100644
--- a/Source/cmStringCommand.cxx
+++ b/Source/cmStringCommand.cxx
@@ -966,21 +966,21 @@
 
 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/cmSystemTools.cxx b/Source/cmSystemTools.cxx
index 6a705f4..024356f 100644
--- a/Source/cmSystemTools.cxx
+++ b/Source/cmSystemTools.cxx
@@ -1255,6 +1255,30 @@
 #endif
 }
 
+void cmSystemTools::ConvertToLongPath(std::string& path)
+{
+#if defined(_WIN32) && !defined(__CYGWIN__)
+  // Try to convert path to a long path only if the path contains character '~'
+  if (path.find('~') == std::string::npos) {
+    return;
+  }
+
+  std::wstring wPath = cmsys::Encoding::ToWide(path);
+  DWORD ret = GetLongPathNameW(wPath.c_str(), nullptr, 0);
+  std::vector<wchar_t> buffer(ret);
+  if (ret != 0) {
+    ret = GetLongPathNameW(wPath.c_str(), buffer.data(),
+                           static_cast<DWORD>(buffer.size()));
+  }
+
+  if (ret != 0) {
+    path = cmsys::Encoding::ToNarrow(buffer.data());
+  }
+#else
+  static_cast<void>(path);
+#endif
+}
+
 std::string cmSystemTools::ConvertToRunCommandPath(const std::string& path)
 {
 #if defined(_WIN32) && !defined(__CYGWIN__)
diff --git a/Source/cmSystemTools.h b/Source/cmSystemTools.h
index 1100f05..5bbbb0c 100644
--- a/Source/cmSystemTools.h
+++ b/Source/cmSystemTools.h
@@ -287,6 +287,12 @@
   // running cmake needs paths to be in its format
   static std::string ConvertToRunCommandPath(const std::string& path);
 
+  /**
+   * For windows computes the long path for the given path,
+   * For Unix, it is a noop
+   */
+  static void ConvertToLongPath(std::string& path);
+
   /** compute the relative path from local to remote.  local must
       be a directory.  remote can be a file or a directory.
       Both remote and local must be full paths.  Basically, if
diff --git a/Source/cmTarget.cxx b/Source/cmTarget.cxx
index 017ab10..1fd2355 100644
--- a/Source/cmTarget.cxx
+++ b/Source/cmTarget.cxx
@@ -230,34 +230,35 @@
   : 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);
@@ -382,6 +383,7 @@
     initProp("UNITY_BUILD");
     initProp("UNITY_BUILD_UNIQUE_ID");
     initProp("OPTIMIZE_DEPENDENCIES");
+    initProp("EXPORT_COMPILE_COMMANDS");
     initPropValue("UNITY_BUILD_BATCH_SIZE", "8");
     initPropValue("UNITY_BUILD_MODE", "BATCH");
     initPropValue("PCH_WARN_INVALID", "ON");
@@ -436,7 +438,7 @@
       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 +451,15 @@
       // 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 +468,67 @@
   }
 
   // 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 +561,40 @@
 
 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 +606,17 @@
                                            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 +626,24 @@
 
 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 +656,74 @@
 {
   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 +734,21 @@
   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 +792,7 @@
 
 std::string cmTarget::GetSourceCMP0049(const std::string& s)
 {
-  return impl->ProcessSourceItemCMP0049(s);
+  return this->impl->ProcessSourceItemCMP0049(s);
 }
 
 struct CreateLocation
@@ -848,23 +851,25 @@
 
 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 +887,7 @@
 
   // 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 +913,14 @@
                                    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 +930,13 @@
   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 +944,59 @@
 
 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 +1018,11 @@
       (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 +1032,11 @@
   // 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 +1063,102 @@
 
 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 +1187,154 @@
   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 +1343,7 @@
       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 +1351,18 @@
 
     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 +1370,102 @@
                               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 +1478,17 @@
       !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 +1499,67 @@
 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 +1728,19 @@
     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 +1748,71 @@
       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 +1820,12 @@
       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 +1838,25 @@
       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 +1881,32 @@
 
 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 +1961,8 @@
                     ? "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 +2002,8 @@
                     ? "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 +2085,7 @@
 
       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 +2093,8 @@
         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 27f0c59..3066eb2 100644
--- a/Source/cmTarget.h
+++ b/Source/cmTarget.h
@@ -172,7 +172,7 @@
   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 bf4cc09..3897499 100644
--- a/Source/cmTargetIncludeDirectoriesCommand.cxx
+++ b/Source/cmTargetIncludeDirectoriesCommand.cxx
@@ -84,8 +84,8 @@
   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 0670bd9..a5066cc 100644
--- a/Source/cmTargetPrecompileHeadersCommand.cxx
+++ b/Source/cmTargetPrecompileHeadersCommand.cxx
@@ -57,7 +57,7 @@
                               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 a1fbc9b..26282ef 100644
--- a/Source/cmTargetSourcesCommand.cxx
+++ b/Source/cmTargetSourcesCommand.cxx
@@ -25,8 +25,9 @@
                               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 @@
                            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 da4593f..7022c4e 100644
--- a/Source/cmTestGenerator.cxx
+++ b/Source/cmTestGenerator.cxx
@@ -147,7 +147,7 @@
 
   // 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 67f7e11..7fb69bf 100644
--- a/Source/cmTimestamp.cxx
+++ b/Source/cmTimestamp.cxx
@@ -38,7 +38,7 @@
     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 @@
   }
 
   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 @@
                                             : 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 df2f64e..e556a11 100644
--- a/Source/cmUVHandlePtr.cxx
+++ b/Source/cmUVHandlePtr.cxx
@@ -80,7 +80,7 @@
 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 @@
     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 @@
 
   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 @@
 
 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 @@
 
 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 d9de7f3..356e227 100644
--- a/Source/cmUVHandlePtr.h
+++ b/Source/cmUVHandlePtr.h
@@ -128,7 +128,7 @@
   // 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 cd52b3f..2513303 100644
--- a/Source/cmUuid.cxx
+++ b/Source/cmUuid.cxx
@@ -82,7 +82,7 @@
       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 @@
 
   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/cmVisualStudio10TargetGenerator.cxx b/Source/cmVisualStudio10TargetGenerator.cxx
index 9c41504..a93a78a 100644
--- a/Source/cmVisualStudio10TargetGenerator.cxx
+++ b/Source/cmVisualStudio10TargetGenerator.cxx
@@ -1897,8 +1897,15 @@
     }
     // Figure out if there's any additional flags to use
     if (cmProp saf = sf->GetProperty("VS_SHADER_FLAGS")) {
+      cmGeneratorExpression ge;
+      std::unique_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(*saf);
+
       for (const std::string& config : this->Configurations) {
-        toolSettings[config]["AdditionalOptions"] = *saf;
+        std::string evaluated = cge->Evaluate(this->LocalGenerator, config);
+
+        if (!evaluated.empty()) {
+          toolSettings[config]["AdditionalOptions"] = evaluated;
+        }
       }
     }
     // Figure out if debug information should be generated
diff --git a/Source/cmWorkerPool.cxx b/Source/cmWorkerPool.cxx
index 12aba4f..f2c091f 100644
--- a/Source/cmWorkerPool.cxx
+++ b/Source/cmWorkerPool.cxx
@@ -50,11 +50,14 @@
   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 @@
 
 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:
   // -- 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 @@
                                 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::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 @@
   // 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 @@
   /**
    * 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 @@
 
 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 @@
   }
   // 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::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 @@
 
 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 @@
 #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::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 @@
                                     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 @@
 
 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 0fb6707..9082d7f 100644
--- a/Source/cmWorkerPool.h
+++ b/Source/cmWorkerPool.h
@@ -28,7 +28,8 @@
     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 @@
      * - 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 @@
      * 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 @@
      * 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 @@
     //! 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:
     //! Does nothing
-    void Process() override { Pool()->Abort(); }
+    void Process() override { this->Pool()->Abort(); }
   };
 
 public:
@@ -161,7 +162,7 @@
   /**
    * 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 @@
    *
    * Only valid during Process().
    */
-  void* UserData() const { return UserData_; }
+  void* UserData() const { return this->UserData_; }
 
   // -- Job processing interface
 
@@ -212,7 +213,7 @@
   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 c8adea9..e593621 100644
--- a/Source/cmWorkingDirectory.h
+++ b/Source/cmWorkingDirectory.h
@@ -26,7 +26,7 @@
 
   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 @@
    *          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/cmXCode21Object.cxx b/Source/cmXCode21Object.cxx
index 1cf9a95..9b0dc58 100644
--- a/Source/cmXCode21Object.cxx
+++ b/Source/cmXCode21Object.cxx
@@ -4,11 +4,12 @@
 
 #include <ostream>
 #include <string>
+#include <utility>
 
 #include "cmSystemTools.h"
 
-cmXCode21Object::cmXCode21Object(PBXType ptype, Type type)
-  : cmXCodeObject(ptype, type)
+cmXCode21Object::cmXCode21Object(PBXType ptype, Type type, std::string id)
+  : cmXCodeObject(ptype, type, std::move(id))
 {
   this->Version = 21;
 }
diff --git a/Source/cmXCode21Object.h b/Source/cmXCode21Object.h
index eb017447..f3fc438 100644
--- a/Source/cmXCode21Object.h
+++ b/Source/cmXCode21Object.h
@@ -13,7 +13,7 @@
 class cmXCode21Object : public cmXCodeObject
 {
 public:
-  cmXCode21Object(PBXType ptype, Type type);
+  cmXCode21Object(PBXType ptype, Type type, std::string id);
   void PrintComment(std::ostream&) override;
   static void PrintList(std::vector<std::unique_ptr<cmXCodeObject>> const&,
                         std::ostream& out, PBXType t);
diff --git a/Source/cmXCodeObject.cxx b/Source/cmXCodeObject.cxx
index b301ab1..d5c5275 100644
--- a/Source/cmXCodeObject.cxx
+++ b/Source/cmXCodeObject.cxx
@@ -40,7 +40,7 @@
   this->Version = 15;
 }
 
-cmXCodeObject::cmXCodeObject(PBXType ptype, Type type)
+cmXCodeObject::cmXCodeObject(PBXType ptype, Type type, std::string id)
 {
   this->Version = 15;
   this->Target = nullptr;
@@ -48,27 +48,7 @@
 
   this->IsA = ptype;
 
-  if (type == OBJECT) {
-    // Set the Id of an Xcode object to a unique string for each instance.
-    // However the Xcode user file references certain Ids: for those cases,
-    // override the generated Id using SetId().
-    //
-    char cUuid[40] = { 0 };
-    CFUUIDRef uuid = CFUUIDCreate(kCFAllocatorDefault);
-    CFStringRef s = CFUUIDCreateString(kCFAllocatorDefault, uuid);
-    CFStringGetCString(s, cUuid, sizeof(cUuid), kCFStringEncodingUTF8);
-    this->Id = cUuid;
-    CFRelease(s);
-    CFRelease(uuid);
-  } else {
-    this->Id =
-      "Temporary cmake object, should not be referred to in Xcode file";
-  }
-
-  cmSystemTools::ReplaceString(this->Id, "-", "");
-  if (this->Id.size() > 24) {
-    this->Id = this->Id.substr(0, 24);
-  }
+  this->Id = std::move(id);
 
   this->TypeValue = type;
   if (this->TypeValue == OBJECT) {
diff --git a/Source/cmXCodeObject.h b/Source/cmXCodeObject.h
index ab7f99e..dd5e86e 100644
--- a/Source/cmXCodeObject.h
+++ b/Source/cmXCodeObject.h
@@ -57,7 +57,7 @@
   };
   static const char* PBXTypeNames[];
   virtual ~cmXCodeObject();
-  cmXCodeObject(PBXType ptype, Type type);
+  cmXCodeObject(PBXType ptype, Type type, std::string id);
   Type GetType() const { return this->TypeValue; }
   PBXType GetIsA() const { return this->IsA; }
 
diff --git a/Source/cmXMLWriter.h b/Source/cmXMLWriter.h
index a16c4c8..8a32377 100644
--- a/Source/cmXMLWriter.h
+++ b/Source/cmXMLWriter.h
@@ -140,9 +140,9 @@
   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 @@
   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 @@
   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 122e022..15f83e0 100644
--- a/Source/cm_codecvt.cxx
+++ b/Source/cm_codecvt.cxx
@@ -35,7 +35,7 @@
     case codecvt::None:
     // No encoding
     default:
-      m_noconv = true;
+      this->m_noconv = true;
   }
 }
 
@@ -43,7 +43,7 @@
 
 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 @@
 {
   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 @@
                                               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/cmake.cxx b/Source/cmake.cxx
index 1691037..48848a7 100644
--- a/Source/cmake.cxx
+++ b/Source/cmake.cxx
@@ -29,6 +29,7 @@
 #include "cm_sys_stat.h"
 
 #include "cmCMakePresetsFile.h"
+#include "cmCommandLineArgument.h"
 #include "cmCommands.h"
 #include "cmDocumentation.h"
 #include "cmDocumentationEntry.h"
@@ -132,131 +133,13 @@
 using JsonValueMapType = std::unordered_map<std::string, Json::Value>;
 #endif
 
-struct CommandArgument
-{
-  enum struct Values
-  {
-    Zero,
-    One,
-    Two,
-  };
-
-  std::string InvalidSyntaxMessage;
-  std::string InvalidValueMessage;
-  std::string Name;
-  CommandArgument::Values Type;
-  std::function<bool(std::string const& value, cmake* state)> StoreCall;
-
-  template <typename FunctionType>
-  CommandArgument(std::string n, CommandArgument::Values t,
-                  FunctionType&& func)
-    : InvalidSyntaxMessage(cmStrCat("Invalid syntax used with ", n))
-    , InvalidValueMessage(cmStrCat("Invalid value used with ", n))
-    , Name(std::move(n))
-    , Type(t)
-    , StoreCall(std::forward<FunctionType>(func))
-  {
-  }
-
-  template <typename FunctionType>
-  CommandArgument(std::string n, std::string failedMsg,
-                  CommandArgument::Values t, FunctionType&& func)
-    : InvalidSyntaxMessage(cmStrCat("Invalid syntax used with ", n))
-    , InvalidValueMessage(std::move(failedMsg))
-    , Name(std::move(n))
-    , Type(t)
-    , StoreCall(std::forward<FunctionType>(func))
-  {
-  }
-
-  bool matches(std::string const& input) const
-  {
-    return cmHasPrefix(input, this->Name);
-  }
-
-  template <typename T>
-  bool parse(std::string const& input, T& index,
-             std::vector<std::string> const& allArgs, cmake* state) const
-  {
-    enum struct ParseMode
-    {
-      Valid,
-      Invalid,
-      SyntaxError,
-      ValueError
-    };
-    ParseMode parseState = ParseMode::Valid;
-
-    // argument is the next parameter
-    if (this->Type == CommandArgument::Values::Zero) {
-      if (input.size() == this->Name.size()) {
-        parseState = this->StoreCall(input, state) ? ParseMode::Valid
-                                                   : ParseMode::Invalid;
-      } else {
-        parseState = ParseMode::SyntaxError;
-      }
-
-    } else if (this->Type == CommandArgument::Values::One) {
-      if (input.size() == this->Name.size()) {
-        ++index;
-        if (index >= allArgs.size() || allArgs[index][0] == '-') {
-          parseState = ParseMode::ValueError;
-        } else {
-          parseState = this->StoreCall(allArgs[index], state)
-            ? ParseMode::Valid
-            : ParseMode::Invalid;
-        }
-      } else {
-        // parse the string to get the value
-        auto possible_value = cm::string_view(input).substr(this->Name.size());
-        if (possible_value.empty()) {
-          parseState = ParseMode::SyntaxError;
-          parseState = ParseMode::ValueError;
-        } else if (possible_value[0] == '=') {
-          possible_value.remove_prefix(1);
-          if (possible_value.empty()) {
-            parseState = ParseMode::ValueError;
-          } else {
-            parseState = this->StoreCall(std::string(possible_value), state)
-              ? ParseMode::Valid
-              : ParseMode::Invalid;
-          }
-        }
-        if (parseState == ParseMode::Valid) {
-          parseState = this->StoreCall(std::string(possible_value), state)
-            ? ParseMode::Valid
-            : ParseMode::Invalid;
-        }
-      }
-    } else if (this->Type == CommandArgument::Values::Two) {
-      if (input.size() == this->Name.size()) {
-        if (index + 2 >= allArgs.size() || allArgs[index + 1][0] == '-' ||
-            allArgs[index + 2][0] == '-') {
-          parseState = ParseMode::ValueError;
-        } else {
-          index += 2;
-          parseState =
-            this->StoreCall(cmStrCat(allArgs[index - 1], ";", allArgs[index]),
-                            state)
-            ? ParseMode::Valid
-            : ParseMode::Invalid;
-        }
-      }
-    }
-
-    if (parseState == ParseMode::SyntaxError) {
-      cmSystemTools::Error(this->InvalidSyntaxMessage);
-    } else if (parseState == ParseMode::ValueError) {
-      cmSystemTools::Error(this->InvalidValueMessage);
-    }
-    return (parseState == ParseMode::Valid);
-  }
-};
-
 auto IgnoreAndTrueLambda = [](std::string const&, cmake*) -> bool {
   return true;
 };
 
+using CommandArgument =
+  cmCommandLineArgument<bool(std::string const& value, cmake* state)>;
+
 } // namespace
 
 static bool cmakeCheckStampFile(const std::string& stampName);
@@ -325,8 +208,9 @@
     };
 
     // The "c" extension MUST precede the "C" extension.
-    setupExts(this->CLikeSourceFileExtensions,
-              { "c", "C", "c++", "cc", "cpp", "cxx", "cu", "m", "M", "mm" });
+    setupExts(
+      this->CLikeSourceFileExtensions,
+      { "c", "C", "c++", "cc", "cpp", "cxx", "cu", "mpp", "m", "M", "mm" });
     setupExts(this->HeaderFileExtensions,
               { "h", "hh", "h++", "hm", "hpp", "hxx", "in", "txx" });
     setupExts(this->CudaFileExtensions, { "cu" });
diff --git a/Source/cmakemain.cxx b/Source/cmakemain.cxx
index f7734a6..ba471b7 100644
--- a/Source/cmakemain.cxx
+++ b/Source/cmakemain.cxx
@@ -5,7 +5,6 @@
 
 #include <algorithm>
 #include <cassert>
-#include <cctype>
 #include <climits>
 #include <cstring>
 #include <iostream>
@@ -19,6 +18,7 @@
 
 #include <cm3p/uv.h>
 
+#include "cmCommandLineArgument.h"
 #include "cmConsoleBuf.h"
 #include "cmDocumentationEntry.h" // IWYU pragma: keep
 #include "cmGlobalGenerator.h"
@@ -213,61 +213,114 @@
   }
 #endif
 
+  bool wizard_mode = false;
   bool sysinfo = false;
   bool list_cached = false;
   bool list_all_cached = false;
   bool list_help = false;
   bool view_only = false;
   cmake::WorkingMode workingMode = cmake::NORMAL_MODE;
-  std::vector<std::string> args;
-  for (int i = 0; i < ac; ++i) {
-    if (strcmp(av[i], "-i") == 0) {
-      /* clang-format off */
-      std::cerr <<
-        "The \"cmake -i\" wizard mode is no longer supported.\n"
-        "Use the -D option to set cache values on the command line.\n"
-        "Use cmake-gui or ccmake for an interactive dialog.\n";
-      /* clang-format on */
-      return 1;
-    }
-    if (strcmp(av[i], "--system-information") == 0) {
-      sysinfo = true;
-    } else if (strcmp(av[i], "-N") == 0) {
-      view_only = true;
-    } else if (strcmp(av[i], "-L") == 0) {
-      list_cached = true;
-    } else if (strcmp(av[i], "-LA") == 0) {
-      list_all_cached = true;
-    } else if (strcmp(av[i], "-LH") == 0) {
-      list_cached = true;
-      list_help = true;
-    } else if (strcmp(av[i], "-LAH") == 0) {
-      list_all_cached = true;
-      list_help = true;
-    } else if (cmHasLiteralPrefix(av[i], "-P")) {
-      if (i == ac - 1) {
-        cmSystemTools::Error("No script specified for argument -P");
-        return 1;
+  std::vector<std::string> parsedArgs;
+
+  using CommandArgument =
+    cmCommandLineArgument<bool(std::string const& value)>;
+  std::vector<CommandArgument> arguments = {
+    CommandArgument{
+      "-i", CommandArgument::Values::Zero,
+      [&wizard_mode](std::string const&) -> bool {
+        /* clang-format off */
+        std::cerr <<
+          "The \"cmake -i\" wizard mode is no longer supported.\n"
+          "Use the -D option to set cache values on the command line.\n"
+          "Use cmake-gui or ccmake for an interactive dialog.\n";
+        /* clang-format on */
+        wizard_mode = true;
+        return true;
+      } },
+    CommandArgument{ "--system-information", CommandArgument::Values::Zero,
+                     [&](std::string const&) -> bool {
+                       sysinfo = true;
+                       return true;
+                     } },
+    CommandArgument{ "-N", CommandArgument::Values::Zero,
+                     [&](std::string const&) -> bool {
+                       view_only = true;
+                       return true;
+                     } },
+    CommandArgument{ "-LAH", CommandArgument::Values::Zero,
+                     [&](std::string const&) -> bool {
+                       list_all_cached = true;
+                       list_help = true;
+                       return true;
+                     } },
+    CommandArgument{ "-LA", CommandArgument::Values::Zero,
+                     [&](std::string const&) -> bool {
+                       list_all_cached = true;
+                       return true;
+                     } },
+    CommandArgument{ "-LH", CommandArgument::Values::Zero,
+                     [&](std::string const&) -> bool {
+                       list_cached = true;
+                       list_help = true;
+                       return true;
+                     } },
+    CommandArgument{ "-L", CommandArgument::Values::Zero,
+                     [&](std::string const&) -> bool {
+                       list_cached = true;
+                       return true;
+                     } },
+    CommandArgument{ "-P", "No script specified for argument -P",
+                     CommandArgument::Values::One,
+                     [&](std::string const& value) -> bool {
+                       workingMode = cmake::SCRIPT_MODE;
+                       parsedArgs.emplace_back("-P");
+                       parsedArgs.push_back(value);
+                       return true;
+                     } },
+    CommandArgument{ "--find-package", CommandArgument::Values::Zero,
+                     [&](std::string const&) -> bool {
+                       workingMode = cmake::FIND_PACKAGE_MODE;
+                       parsedArgs.emplace_back("--find-package");
+                       return true;
+                     } },
+    CommandArgument{ "--list-presets", CommandArgument::Values::Zero,
+                     [&](std::string const&) -> bool {
+                       workingMode = cmake::HELP_MODE;
+                       parsedArgs.emplace_back("--list-presets");
+                       return true;
+                     } },
+  };
+
+  std::vector<std::string> inputArgs;
+  inputArgs.reserve(ac);
+  cm::append(inputArgs, av, av + ac);
+
+  for (decltype(inputArgs.size()) i = 0; i < inputArgs.size(); ++i) {
+    std::string const& arg = inputArgs[i];
+    bool matched = false;
+    for (auto const& m : arguments) {
+      if (m.matches(arg)) {
+        matched = true;
+        if (m.parse(arg, i, inputArgs)) {
+          break;
+        }
+        return 1; // failed to parse
       }
-      workingMode = cmake::SCRIPT_MODE;
-      args.emplace_back(av[i]);
-      i++;
-      args.emplace_back(av[i]);
-    } else if (cmHasLiteralPrefix(av[i], "--find-package")) {
-      workingMode = cmake::FIND_PACKAGE_MODE;
-      args.emplace_back(av[i]);
-    } else if (strcmp(av[i], "--list-presets") == 0) {
-      workingMode = cmake::HELP_MODE;
-      args.emplace_back(av[i]);
-    } else {
-      args.emplace_back(av[i]);
+    }
+    if (!matched) {
+      parsedArgs.emplace_back(av[i]);
     }
   }
+
+  if (wizard_mode) {
+    return 1;
+  }
+
   if (sysinfo) {
     cmake cm(cmake::RoleProject, cmState::Project);
     cm.SetHomeDirectory("");
     cm.SetHomeOutputDirectory("");
-    int ret = cm.GetSystemInformation(args);
+    int ret = cm.GetSystemInformation(parsedArgs);
     return ret;
   }
   cmake::Role const role =
@@ -297,7 +350,7 @@
   });
   cm.SetWorkingMode(workingMode);
 
-  int res = cm.Run(args, view_only);
+  int res = cm.Run(parsedArgs, view_only);
   if (list_cached || list_all_cached) {
     std::cout << "-- Cache values" << std::endl;
     std::vector<std::string> keys = cm.GetState()->GetCacheEntryKeys();
@@ -332,16 +385,9 @@
 }
 
 #ifndef CMAKE_BOOTSTRAP
-int extract_job_number(int& index, char const* current, char const* next,
-                       int len_of_flag)
+int extract_job_number(std::string const& command,
+                       std::string const& jobString)
 {
-  std::string command(current);
-  std::string jobString = command.substr(len_of_flag);
-  if (jobString.empty() && next && isdigit(next[0])) {
-    ++index; // skip parsing the job number
-    jobString = std::string(next);
-  }
-
   int jobs = -1;
   unsigned long numJobs = 0;
   if (jobString.empty()) {
@@ -356,8 +402,8 @@
       jobs = int(numJobs);
     }
   } else {
-    std::cerr << "'" << command.substr(0, len_of_flag) << "' invalid number '"
-              << jobString << "' given.\n\n";
+    std::cerr << "'" << command << "' invalid number '" << jobString
+              << "' given.\n\n";
   }
   return jobs;
 }
@@ -374,88 +420,107 @@
   std::string config;
   std::string dir;
   std::vector<std::string> nativeOptions;
+  bool nativeOptionsPassed = false;
   bool cleanFirst = false;
   bool foundClean = false;
   bool foundNonClean = false;
   bool verbose = cmSystemTools::HasEnv("VERBOSE");
 
-  enum Doing
-  {
-    DoingNone,
-    DoingDir,
-    DoingTarget,
-    DoingConfig,
-    DoingNative
+  auto jLambda = [&](std::string const& value) -> bool {
+    jobs = extract_job_number("-j", value);
+    if (jobs < 0) {
+      dir.clear();
+    }
+    return true;
   };
-  Doing doing = DoingDir;
-  for (int i = 2; i < ac; ++i) {
-    if (doing == DoingNative) {
-      nativeOptions.emplace_back(av[i]);
-    } else if (cmHasLiteralPrefix(av[i], "-j")) {
-      const char* nextArg = ((i + 1 < ac) ? av[i + 1] : nullptr);
-      jobs = extract_job_number(i, av[i], nextArg, sizeof("-j") - 1);
-      if (jobs < 0) {
-        dir.clear();
+  auto parallelLambda = [&](std::string const& value) -> bool {
+    jobs = extract_job_number("--parallel", value);
+    if (jobs < 0) {
+      dir.clear();
+    }
+    return true;
+  };
+  auto targetLambda = [&](std::string const& value) -> bool {
+    if (!value.empty()) {
+      std::vector<std::string> values = cmExpandedList(value);
+      for (auto const& v : values) {
+        targets.emplace_back(v);
+        if (v == "clean") {
+          foundClean = true;
+        } else {
+          foundNonClean = true;
+        }
       }
-      doing = DoingNone;
-    } else if (cmHasLiteralPrefix(av[i], "--parallel")) {
-      const char* nextArg = ((i + 1 < ac) ? av[i + 1] : nullptr);
-      jobs = extract_job_number(i, av[i], nextArg, sizeof("--parallel") - 1);
-      if (jobs < 0) {
-        dir.clear();
-      }
-      doing = DoingNone;
-    } else if ((strcmp(av[i], "--target") == 0) ||
-               (strcmp(av[i], "-t") == 0)) {
-      doing = DoingTarget;
-    } else if (strcmp(av[i], "--config") == 0) {
-      doing = DoingConfig;
-    } else if (strcmp(av[i], "--clean-first") == 0) {
-      cleanFirst = true;
-      doing = DoingNone;
-    } else if ((strcmp(av[i], "--verbose") == 0) ||
-               (strcmp(av[i], "-v") == 0)) {
-      verbose = true;
-      doing = DoingNone;
-    } else if (strcmp(av[i], "--use-stderr") == 0) {
-      /* tolerate legacy option */
-    } else if (strcmp(av[i], "--") == 0) {
-      doing = DoingNative;
-    } else {
-      switch (doing) {
-        case DoingDir:
-          dir = cmSystemTools::CollapseFullPath(av[i]);
-          doing = DoingNone;
+      return true;
+    }
+    return false;
+  };
+  auto verboseLambda = [&](std::string const&) -> bool {
+    verbose = true;
+    return true;
+  };
+
+  using CommandArgument =
+    cmCommandLineArgument<bool(std::string const& value)>;
+
+  std::vector<CommandArgument> arguments = {
+    CommandArgument{ "-j", CommandArgument::Values::ZeroOrOne, jLambda },
+    CommandArgument{ "--parallel", CommandArgument::Values::ZeroOrOne,
+                     parallelLambda },
+    CommandArgument{ "-t", CommandArgument::Values::OneOrMore, targetLambda },
+    CommandArgument{ "--target", CommandArgument::Values::OneOrMore,
+                     targetLambda },
+    CommandArgument{ "--config", CommandArgument::Values::One,
+                     [&](std::string const& value) -> bool {
+                       config = value;
+                       return true;
+                     } },
+    CommandArgument{ "--clean-first", CommandArgument::Values::Zero,
+                     [&](std::string const&) -> bool {
+                       cleanFirst = true;
+                       return true;
+                     } },
+    CommandArgument{ "-v", CommandArgument::Values::Zero, verboseLambda },
+    CommandArgument{ "--verbose", CommandArgument::Values::Zero,
+                     verboseLambda },
+    /* legacy option no-op*/
+    CommandArgument{ "--use-stderr", CommandArgument::Values::Zero,
+                     [](std::string const&) -> bool { return true; } },
+    CommandArgument{ "--", CommandArgument::Values::Zero,
+                     [&](std::string const&) -> bool {
+                       nativeOptionsPassed = true;
+                       return true;
+                     } },
+  };
+
+  if (ac >= 3) {
+    dir = cmSystemTools::CollapseFullPath(av[2]);
+
+    std::vector<std::string> inputArgs;
+    inputArgs.reserve(ac - 3);
+    cm::append(inputArgs, av + 3, av + ac);
+
+    decltype(inputArgs.size()) i = 0;
+    for (; i < inputArgs.size() && !nativeOptionsPassed; ++i) {
+
+      std::string const& arg = inputArgs[i];
+      for (auto const& m : arguments) {
+        if (m.matches(arg) && m.parse(arg, i, inputArgs)) {
           break;
-        case DoingTarget:
-          if (strlen(av[i]) == 0) {
-            std::cerr << "Warning: Argument number " << i
-                      << " after --target option is empty." << std::endl;
-          } else {
-            targets.emplace_back(av[i]);
-            if (strcmp(av[i], "clean") == 0) {
-              foundClean = true;
-            } else {
-              foundNonClean = true;
-            }
-          }
-          if (foundClean && foundNonClean) {
-            std::cerr << "Error: Building 'clean' and other targets together "
-                         "is not supported."
-                      << std::endl;
-            dir.clear();
-          }
-          break;
-        case DoingConfig:
-          config = av[i];
-          doing = DoingNone;
-          break;
-        default:
-          std::cerr << "Unknown argument " << av[i] << std::endl;
-          dir.clear();
-          break;
+        }
       }
     }
+
+    if (nativeOptionsPassed) {
+      cm::append(nativeOptions, inputArgs.begin() + i, inputArgs.end());
+    }
+  }
+
+  if (foundClean && foundNonClean) {
+    std::cerr << "Error: Building 'clean' and other targets together "
+                 "is not supported."
+              << std::endl;
+    dir.clear();
   }
 
   if (jobs == cmake::NO_BUILD_PARALLEL_LEVEL) {
@@ -658,60 +723,59 @@
   bool strip = false;
   bool verbose = cmSystemTools::HasEnv("VERBOSE");
 
-  enum Doing
-  {
-    DoingNone,
-    DoingDir,
-    DoingConfig,
-    DoingComponent,
-    DoingPrefix,
-    DoingDefaultDirectoryPermissions,
+  auto verboseLambda = [&](std::string const&) -> bool {
+    verbose = true;
+    return true;
   };
 
-  Doing doing = DoingDir;
+  using CommandArgument =
+    cmCommandLineArgument<bool(std::string const& value)>;
 
-  for (int i = 2; i < ac; ++i) {
-    if (strcmp(av[i], "--config") == 0) {
-      doing = DoingConfig;
-    } else if (strcmp(av[i], "--component") == 0) {
-      doing = DoingComponent;
-    } else if (strcmp(av[i], "--prefix") == 0) {
-      doing = DoingPrefix;
-    } else if (strcmp(av[i], "--strip") == 0) {
-      strip = true;
-      doing = DoingNone;
-    } else if ((strcmp(av[i], "--verbose") == 0) ||
-               (strcmp(av[i], "-v") == 0)) {
-      verbose = true;
-      doing = DoingNone;
-    } else if (strcmp(av[i], "--default-directory-permissions") == 0) {
-      doing = DoingDefaultDirectoryPermissions;
-    } else {
-      switch (doing) {
-        case DoingDir:
-          dir = cmSystemTools::CollapseFullPath(av[i]);
-          doing = DoingNone;
+  std::vector<CommandArgument> arguments = {
+    CommandArgument{ "--config", CommandArgument::Values::One,
+                     [&](std::string const& value) -> bool {
+                       config = value;
+                       return true;
+                     } },
+    CommandArgument{ "--component", CommandArgument::Values::One,
+                     [&](std::string const& value) -> bool {
+                       component = value;
+                       return true;
+                     } },
+    CommandArgument{ "--default-directory-permissions",
+                     CommandArgument::Values::One,
+                     [&](std::string const& value) -> bool {
+                       defaultDirectoryPermissions = value;
+                       return true;
+                     } },
+    CommandArgument{ "--prefix", CommandArgument::Values::One,
+                     [&](std::string const& value) -> bool {
+                       prefix = value;
+                       return true;
+                     } },
+    CommandArgument{ "--strip", CommandArgument::Values::Zero,
+                     [&](std::string const&) -> bool {
+                       strip = true;
+                       return true;
+                     } },
+    CommandArgument{ "-v", CommandArgument::Values::Zero, verboseLambda },
+    CommandArgument{ "--verbose", CommandArgument::Values::Zero,
+                     verboseLambda }
+  };
+
+  if (ac >= 3) {
+    dir = cmSystemTools::CollapseFullPath(av[2]);
+
+    std::vector<std::string> inputArgs;
+    inputArgs.reserve(ac - 3);
+    cm::append(inputArgs, av + 3, av + ac);
+    for (decltype(inputArgs.size()) i = 0; i < inputArgs.size(); ++i) {
+
+      std::string const& arg = inputArgs[i];
+      for (auto const& m : arguments) {
+        if (m.matches(arg) && m.parse(arg, i, inputArgs)) {
           break;
-        case DoingConfig:
-          config = av[i];
-          doing = DoingNone;
-          break;
-        case DoingComponent:
-          component = av[i];
-          doing = DoingNone;
-          break;
-        case DoingPrefix:
-          prefix = av[i];
-          doing = DoingNone;
-          break;
-        case DoingDefaultDirectoryPermissions:
-          defaultDirectoryPermissions = av[i];
-          doing = DoingNone;
-          break;
-        default:
-          std::cerr << "Unknown argument " << av[i] << std::endl;
-          dir.clear();
-          break;
+        }
       }
     }
   }
diff --git a/Source/cmcmd.cxx b/Source/cmcmd.cxx
index 73fbfb6..851205e 100644
--- a/Source/cmcmd.cxx
+++ b/Source/cmcmd.cxx
@@ -231,11 +231,10 @@
   bool ProcessLine() override
   {
     if (cmHasPrefix(this->Line, this->IncludePrefix)) {
-      this->DepFile << cmCMakePath(
-                         cmTrimWhitespace(this->Line.c_str() +
-                                          this->IncludePrefix.size()))
-                         .GenericString()
-                    << std::endl;
+      auto path =
+        cmTrimWhitespace(this->Line.c_str() + this->IncludePrefix.size());
+      cmSystemTools::ConvertToLongPath(path);
+      this->DepFile << cmCMakePath(path).GenericString() << std::endl;
     } else {
       this->Output << this->Line << std::endl << std::flush;
     }
@@ -2227,7 +2226,7 @@
     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 +2235,7 @@
       std::cout << "Visual Studio Incremental Link without manifests\n";
     }
   }
-  return LinkNonIncremental();
+  return this->LinkNonIncremental();
 }
 
 static bool mtRetIsUpdate(int mtRet)
diff --git a/Source/kwsys/SystemInformation.cxx b/Source/kwsys/SystemInformation.cxx
index 9c34a56..9607c00 100644
--- a/Source/kwsys/SystemInformation.cxx
+++ b/Source/kwsys/SystemInformation.cxx
@@ -447,6 +447,7 @@
     Motorola,
     HP,
     Hygon,
+    Zhaoxin,
     UnknownManufacturer
   };
 
@@ -1731,7 +1732,8 @@
     case NexGen:
       return "NexGen Inc., Advanced Micro Devices";
     case IDT:
-      return "IDT\\Centaur, Via Inc.";
+      return "IDT\\Centaur, Via Inc., Shanghai Zhaoxin Semiconductor Co., "
+             "Ltd.";
     case UMC:
       return "United Microelectronics Corp.";
     case Rise:
@@ -1748,6 +1750,8 @@
       return "Hewlett-Packard";
     case Hygon:
       return "Chengdu Haiguang IC Design Co., Ltd.";
+    case Zhaoxin:
+      return "Shanghai Zhaoxin Semiconductor Co., Ltd.";
     case UnknownManufacturer:
     default:
       return "Unknown Manufacturer";
@@ -2109,7 +2113,10 @@
   else if (this->ChipID.Vendor == "NexGenDriven")
     this->ChipManufacturer = NexGen; // NexGen Inc. (now AMD)
   else if (this->ChipID.Vendor == "CentaurHauls")
-    this->ChipManufacturer = IDT; // IDT/Centaur (now VIA)
+    this->ChipManufacturer = IDT; // original IDT/Centaur/VIA (now Zhaoxin)
+  else if (this->ChipID.Vendor == "  Shanghai  ")
+    this->ChipManufacturer =
+      Zhaoxin; // Shanghai Zhaoxin Semiconductor Co., Ltd.
   else if (this->ChipID.Vendor == "RiseRiseRise")
     this->ChipManufacturer = Rise; // Rise
   else if (this->ChipID.Vendor == "GenuineTMx86")
@@ -3223,7 +3230,8 @@
               this->ChipID.ProcessorName = "C3";
               break;
             default:
-              this->ChipID.ProcessorName = "Unknown IDT\\Centaur family";
+              this->ChipID.ProcessorName =
+                "Unknown IDT\\Centaur\\VIA\\Zhaoxin family";
               return false;
           }
           break;
@@ -3232,13 +3240,63 @@
             case 6:
               this->ChipID.ProcessorName = "VIA Cyrix III - Samuel";
               break;
+            case 0xf:
+              this->ChipID.ProcessorName = "Zhaoxin zxc";
+              break;
             default:
-              this->ChipID.ProcessorName = "Unknown IDT\\Centaur family";
+              this->ChipID.ProcessorName =
+                "Unknown IDT\\Centaur\\VIA\\Zhaoxin family";
+              return false;
+          }
+          break;
+        case 7:
+          switch (this->ChipID.Model) {
+            case 0x1b:
+              this->ChipID.ProcessorName = "Zhaoxin kx5000";
+              break;
+            case 0x3b:
+              this->ChipID.ProcessorName = "Zhaoxin kx6000";
+              break;
+            default:
+              this->ChipID.ProcessorName =
+                "Unknown IDT\\Centaur\\VIA\\Zhaoxin family";
               return false;
           }
           break;
         default:
-          this->ChipID.ProcessorName = "Unknown IDT\\Centaur family";
+          this->ChipID.ProcessorName =
+            "Unknown IDT\\Centaur\\VIA\\Zhaoxin family";
+          return false;
+      }
+      break;
+
+    case Zhaoxin:
+      switch (this->ChipID.Family) {
+        case 6:
+          switch (this->ChipID.Model) {
+            case 0x19:
+              this->ChipID.ProcessorName = "Zhaoxin zxc";
+              break;
+            default:
+              this->ChipID.ProcessorName = "Unknown Zhaoxin family";
+              return false;
+          }
+          break;
+        case 7:
+          switch (this->ChipID.Model) {
+            case 0x1b:
+              this->ChipID.ProcessorName = "Zhaoxin kx5000";
+              break;
+            case 0x3b:
+              this->ChipID.ProcessorName = "Zhaoxin kx6000";
+              break;
+            default:
+              this->ChipID.ProcessorName = "Unknown Zhaoxin family";
+              return false;
+          }
+          break;
+        default:
+          this->ChipID.ProcessorName = "Unknown Zhaoxin family";
           return false;
       }
       break;
diff --git a/Tests/CMakeLib/run_compile_commands.cxx b/Tests/CMakeLib/run_compile_commands.cxx
index 2c77acc..0fd6cfb 100644
--- a/Tests/CMakeLib/run_compile_commands.cxx
+++ b/Tests/CMakeLib/run_compile_commands.cxx
@@ -36,8 +36,8 @@
 
   void Parse()
   {
-    NextNonWhitespace();
-    ParseTranslationUnits();
+    this->NextNonWhitespace();
+    this->ParseTranslationUnits();
   }
 
   const TranslationUnitsType& GetTranslationUnits()
@@ -49,51 +49,51 @@
   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 @@
 
   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 2aeaf7f..d8932ce 100644
--- a/Tests/CMakeLib/testCMExtMemory.cxx
+++ b/Tests/CMakeLib/testCMExtMemory.cxx
@@ -26,9 +26,9 @@
     : 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/Tests/CMakeLists.txt b/Tests/CMakeLists.txt
index 2a59d66..74fca5c 100644
--- a/Tests/CMakeLists.txt
+++ b/Tests/CMakeLists.txt
@@ -3394,6 +3394,9 @@
               ${build_generator_args}
               --build-project helloJavaNativeHeaders
               --build-run-dir "${CMake_BINARY_DIR}/Tests/JavaNativeHeaders/"
+              --build-target install
+              --build-options
+              "-DCMAKE_INSTALL_PREFIX:PATH=${CMake_BINARY_DIR}/Tests/JavaNativeHeaders/Install"
               --test-command ${CMAKE_CTEST_COMMAND} -V -C $<CONFIG>)
             list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/JavaNativeHeaders")
           endif()
diff --git a/Tests/CMakeTests/ListTest.cmake.in b/Tests/CMakeTests/ListTest.cmake.in
index 785f41d..76737e5 100644
--- a/Tests/CMakeTests/ListTest.cmake.in
+++ b/Tests/CMakeTests/ListTest.cmake.in
@@ -142,9 +142,8 @@
 set(Insert-List-Only-STDERR "at least three")
 set(Length-List-Only-STDERR "two")
 set(Remove_At-List-Only-STDERR "at least two")
-set(Remove_Item-List-Only-STDERR "two or more")
 
-foreach(cmd IN ITEMS Find Get Insert Length Remove_At Remove_Item)
+foreach(cmd IN ITEMS Find Get Insert Length Remove_At)
   string(TOUPPER ${cmd} cmd_upper)
   set(${cmd}-List-Only-RESULT 1)
   set(${cmd}-List-Only-STDERR ".*CMake Error at List-${cmd}-List-Only.cmake:1 \\(list\\):.*list sub-command ${cmd_upper} requires ${${cmd}-List-Only-STDERR} arguments.*")
diff --git a/Tests/ConfigSources/CMakeLists.txt b/Tests/ConfigSources/CMakeLists.txt
index ab0b5d8..a3d98f6 100644
--- a/Tests/ConfigSources/CMakeLists.txt
+++ b/Tests/ConfigSources/CMakeLists.txt
@@ -5,6 +5,11 @@
 endif()
 project(ConfigSources CXX)
 
+if("${CMAKE_CXX_COMPILER_ID};${CMAKE_CXX_SIMULATE_ID}" STREQUAL "Intel;MSVC")
+  string(APPEND CMAKE_CXX_FLAGS_DEBUG " -Z7")
+  string(APPEND CMAKE_CXX_FLAGS_RELWITHDEBINFO " -Z7")
+endif()
+
 # Source file(s) named with the configuration(s).
 file(GENERATE
   OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/config_$<CONFIG>.cpp"
diff --git a/Tests/CustomCommand/CMakeLists.txt b/Tests/CustomCommand/CMakeLists.txt
index c1a7a57..80545c4 100644
--- a/Tests/CustomCommand/CMakeLists.txt
+++ b/Tests/CustomCommand/CMakeLists.txt
@@ -582,3 +582,7 @@
   )
 add_custom_command(OUTPUT mac_fw.txt COMMAND ${CMAKE_COMMAND} -E touch mac_fw.txt DEPENDS mac_fw)
 add_custom_target(drive_mac_fw ALL DEPENDS mac_fw.txt)
+
+# Test empty COMMANDs are ommited
+add_executable(empty_command empty_command.cxx)
+add_custom_command(TARGET empty_command POST_BUILD COMMAND $<0:date>)
diff --git a/Tests/CustomCommand/empty_command.cxx b/Tests/CustomCommand/empty_command.cxx
new file mode 100644
index 0000000..f8b643a
--- /dev/null
+++ b/Tests/CustomCommand/empty_command.cxx
@@ -0,0 +1,4 @@
+int main()
+{
+  return 0;
+}
diff --git a/Tests/JavaNativeHeaders/CMakeLists.txt b/Tests/JavaNativeHeaders/CMakeLists.txt
index 2023d25..f3cc89d 100644
--- a/Tests/JavaNativeHeaders/CMakeLists.txt
+++ b/Tests/JavaNativeHeaders/CMakeLists.txt
@@ -11,7 +11,7 @@
 # JNI support
 find_package(JNI)
 
-add_jar(B1 D.java GENERATE_NATIVE_HEADERS D1-native)
+add_jar(B1 D.java GENERATE_NATIVE_HEADERS D1-native DESTINATION INSTALL include)
 add_jar(E1 E.java GENERATE_NATIVE_HEADERS E1-native)
 
 add_jar(hello4 HelloWorld3.java)
@@ -19,6 +19,13 @@
 add_library(D SHARED D.cpp E.cpp)
 target_link_libraries (D PRIVATE D1-native E1-native)
 
+install(TARGETS D1-native EXPORT native)
+install(DIRECTORY "$<TARGET_PROPERTY:D1-native,NATIVE_HEADERS_DIRECTORY>/" DESTINATION include)
+install(EXPORT native DESTINATION "${CMAKE_INSTALL_PREFIX}" NAMESPACE D1::)
+
 
 add_test (NAME Java.NativeHeaders
           COMMAND "${Java_JAVA_EXECUTABLE}" -Djava.library.path=$<TARGET_FILE_DIR:D> -classpath hello4.jar HelloWorld3)
+
+add_test (NAME Java.ImportNativeHeaders
+          COMMAND "${CMAKE_COMMAND}" "-DNATIVE_HEADERS_IMPORT_DIR=${CMAKE_INSTALL_PREFIX}" -S "${CMAKE_CURRENT_SOURCE_DIR}/Import" -B "${CMAKE_CURRENT_BINARY_DIR}/Import")
diff --git a/Tests/JavaNativeHeaders/Import/CMakeLists.txt b/Tests/JavaNativeHeaders/Import/CMakeLists.txt
new file mode 100644
index 0000000..5486da9
--- /dev/null
+++ b/Tests/JavaNativeHeaders/Import/CMakeLists.txt
@@ -0,0 +1,19 @@
+project(ImportJavaNativeHeaders LANGUAGES NONE)
+
+cmake_minimum_required (VERSION 3.19...3.20)
+set(CMAKE_VERBOSE_MAKEFILE 1)
+
+include(${NATIVE_HEADERS_IMPORT_DIR}/native.cmake)
+
+if(NOT TARGET D1::D1-native)
+  message(FATAL_ERROR "Target 'D1::D1-native' not found.")
+endif()
+
+get_property(incs TARGET D1::D1-native PROPERTY INTERFACE_INCLUDE_DIRECTORIES)
+if (NOT incs MATCHES "${NATIVE_HEADERS_IMPORT_DIR}/include")
+  message(FATAL_ERROR "Target 'D1::D1-native', property 'INTERFACE_INCLUDE_DIRECTORIES' badly defined: ${incs}.")
+endif()
+
+if (NOT EXISTS "${NATIVE_HEADERS_IMPORT_DIR}/include/D.h")
+  message(FATAL_ERROR "file '${NATIVE_HEADERS_IMPORT_DIR}/include/D.h' not found.")
+endif()
diff --git a/Tests/QtAutogen/RerunMocBasic/CMakeLists.txt b/Tests/QtAutogen/RerunMocBasic/CMakeLists.txt
index 9b32e59..c53e857 100644
--- a/Tests/QtAutogen/RerunMocBasic/CMakeLists.txt
+++ b/Tests/QtAutogen/RerunMocBasic/CMakeLists.txt
@@ -47,19 +47,38 @@
 endmacro()
 
 
-# Initial build
+# Configure the test project
 configure_file("${mocBasicSrcDir}/test1a.h.in" "${mocBasicBinDir}/test1.h" COPYONLY)
-try_compile(MOC_RERUN
-  "${mocBasicBinDir}"
-  "${mocBasicSrcDir}"
-  MocBasic
-  CMAKE_FLAGS "-DQT_TEST_VERSION=${QT_TEST_VERSION}"
-              "-DCMAKE_AUTOGEN_VERBOSE=${CMAKE_AUTOGEN_VERBOSE}"
-              "-DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}"
+configure_file("${mocBasicSrcDir}/myobject3a.h.in" "${mocBasicBinDir}/myobject3.h" @ONLY)
+if(CMAKE_GENERATOR_INSTANCE)
+    set(_D_CMAKE_GENERATOR_INSTANCE "-DCMAKE_GENERATOR_INSTANCE=${CMAKE_GENERATOR_INSTANCE}")
+else()
+    set(_D_CMAKE_GENERATOR_INSTANCE "")
+endif()
+execute_process(
+  COMMAND "${CMAKE_COMMAND}" -B "${mocBasicBinDir}" -S "${mocBasicSrcDir}"
+          -G "${CMAKE_GENERATOR}"
+          -A "${CMAKE_GENERATOR_PLATFORM}"
+          -T "${CMAKE_GENERATOR_TOOLSET}"
+          ${_D_CMAKE_GENERATOR_INSTANCE}
+          "-DQT_TEST_VERSION=${QT_TEST_VERSION}"
+          "-DCMAKE_AUTOGEN_VERBOSE=${CMAKE_AUTOGEN_VERBOSE}"
+          "-DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}"
+  RESULT_VARIABLE exit_code
   OUTPUT_VARIABLE output
 )
-if (NOT MOC_RERUN)
-  message(FATAL_ERROR "Initial build of mocBasic failed. Output: ${output}")
+if(NOT exit_code EQUAL 0)
+  message(FATAL_ERROR "Initial configuration of mocBasic failed. Output: ${output}")
+endif()
+
+# Initial build
+execute_process(
+    COMMAND "${CMAKE_COMMAND}" --build "${mocBasicBinDir}"
+    RESULT_VARIABLE exit_code
+    OUTPUT_VARIABLE output
+)
+if(NOT exit_code EQUAL 0)
+    message(FATAL_ERROR "Initial build of mocBasic failed. Output: ${output}")
 endif()
 
 # Get name of the output binary
@@ -100,3 +119,43 @@
 rebuild(3)
 acquire_timestamp(After)
 require_change_not()
+
+
+# - Ensure that the timestamp will change
+# - Remove Q_OBJECT from header
+# - Rebuild
+acquire_timestamp(Before)
+sleep()
+message(STATUS "Remove Q_OBJECT from header file for a MOC re-run")
+configure_file("${mocBasicSrcDir}/test1c.h.in" "${mocBasicBinDir}/test1.h" COPYONLY)
+sleep()
+rebuild(4)
+acquire_timestamp(After)
+require_change()
+
+
+# - Ensure that the timestamp will change
+# - Add Q_OBJECT to header again
+# - Rebuild
+acquire_timestamp(Before)
+sleep()
+message(STATUS "Add Q_OBJECT to test1.h for a MOC re-run")
+configure_file("${mocBasicSrcDir}/test1a.h.in" "${mocBasicBinDir}/test1.h" COPYONLY)
+sleep()
+rebuild(5)
+acquire_timestamp(After)
+require_change()
+
+
+# - Ensure that the timestamp will change
+# - Add Q_OBJECT to MyObject3
+# - Rebuild
+acquire_timestamp(Before)
+sleep()
+message(STATUS "Add Q_OBJECT to myobject3.h file for a MOC re-run")
+set(CLASS_CONTENT "Q_OBJECT")
+configure_file("${mocBasicSrcDir}/myobject3a.h.in" "${mocBasicBinDir}/myobject3.h" @ONLY)
+sleep()
+rebuild(6)
+acquire_timestamp(After)
+require_change()
diff --git a/Tests/QtAutogen/RerunMocBasic/MocBasic/CMakeLists.txt b/Tests/QtAutogen/RerunMocBasic/MocBasic/CMakeLists.txt
index 6a9f550..42f2f57 100644
--- a/Tests/QtAutogen/RerunMocBasic/MocBasic/CMakeLists.txt
+++ b/Tests/QtAutogen/RerunMocBasic/MocBasic/CMakeLists.txt
@@ -13,10 +13,15 @@
 
 add_executable(mocBasic
   ${CMAKE_CURRENT_BINARY_DIR}/test1.h
+  ${CMAKE_CURRENT_BINARY_DIR}/myobject3.h
   ${CMAKE_CURRENT_BINARY_DIR}/main.cpp
+  plainobject.cpp
   res1.qrc
 )
-target_include_directories(mocBasic PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
+target_include_directories(mocBasic PRIVATE
+    ${CMAKE_CURRENT_BINARY_DIR}
+    ${CMAKE_CURRENT_SOURCE_DIR}
+)
 target_link_libraries(mocBasic ${QT_QTCORE_TARGET})
 # Write target name to text file
 add_custom_command(TARGET mocBasic POST_BUILD COMMAND
diff --git a/Tests/QtAutogen/RerunMocBasic/MocBasic/main.cpp.in b/Tests/QtAutogen/RerunMocBasic/MocBasic/main.cpp.in
index 9d7ea37..5accfd6 100644
--- a/Tests/QtAutogen/RerunMocBasic/MocBasic/main.cpp.in
+++ b/Tests/QtAutogen/RerunMocBasic/MocBasic/main.cpp.in
@@ -1,4 +1,5 @@
 #include "test1.h"
+#include "plainobject.h"
 
 extern int qInitResources_res1();
 
@@ -16,6 +17,7 @@
 
   Test1 test1;
   Test2 test2;
+  PlainObject plainObject;
 
   return 0;
 }
diff --git a/Tests/QtAutogen/RerunMocBasic/MocBasic/myobject3a.h.in b/Tests/QtAutogen/RerunMocBasic/MocBasic/myobject3a.h.in
new file mode 100644
index 0000000..d62c314
--- /dev/null
+++ b/Tests/QtAutogen/RerunMocBasic/MocBasic/myobject3a.h.in
@@ -0,0 +1,13 @@
+#ifndef MYOBJECT3_H
+#define MYOBJECT3_H
+
+#include <qobject.h>
+
+class MyObject3 : public QObject
+{
+    @CLASS_CONTENT@
+public:
+    MyObject3() {}
+};
+
+#endif
diff --git a/Tests/QtAutogen/RerunMocBasic/MocBasic/plainobject.cpp b/Tests/QtAutogen/RerunMocBasic/MocBasic/plainobject.cpp
new file mode 100644
index 0000000..0ca785e
--- /dev/null
+++ b/Tests/QtAutogen/RerunMocBasic/MocBasic/plainobject.cpp
@@ -0,0 +1,12 @@
+#include "plainobject.h"
+
+#include "myobject3.h"
+
+PlainObject::PlainObject()
+{
+}
+
+void PlainObject::doSomething()
+{
+  MyObject3 obj3;
+}
diff --git a/Tests/QtAutogen/RerunMocBasic/MocBasic/plainobject.h b/Tests/QtAutogen/RerunMocBasic/MocBasic/plainobject.h
new file mode 100644
index 0000000..8037858
--- /dev/null
+++ b/Tests/QtAutogen/RerunMocBasic/MocBasic/plainobject.h
@@ -0,0 +1,12 @@
+#ifndef PLAINOBJECT_H
+#define PLAINOBJECT_H
+
+// Class that is plain C++, no Qt involved.
+class PlainObject
+{
+public:
+  PlainObject();
+  void doSomething();
+};
+
+#endif
diff --git a/Tests/QtAutogen/RerunMocBasic/MocBasic/test1c.h.in b/Tests/QtAutogen/RerunMocBasic/MocBasic/test1c.h.in
new file mode 100644
index 0000000..d0b9868
--- /dev/null
+++ b/Tests/QtAutogen/RerunMocBasic/MocBasic/test1c.h.in
@@ -0,0 +1,6 @@
+#include <QObject>
+class Test1
+{
+public:
+  void onTst1() {}
+};
diff --git a/Tests/RunCMake/BuildDepends/MakeDependencies.cmake b/Tests/RunCMake/BuildDepends/MakeDependencies.cmake
new file mode 100644
index 0000000..33e8c7e
--- /dev/null
+++ b/Tests/RunCMake/BuildDepends/MakeDependencies.cmake
@@ -0,0 +1,13 @@
+enable_language(C)
+
+add_executable(main ${CMAKE_CURRENT_BINARY_DIR}/main.c)
+
+file(GENERATE OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/check-$<LOWER_CASE:$<CONFIG>>.cmake CONTENT "
+set(check_pairs
+  \"$<TARGET_FILE:main>|${CMAKE_CURRENT_BINARY_DIR}/main.c\"
+  \"$<TARGET_FILE:main>|${CMAKE_CURRENT_BINARY_DIR}/main.h\"
+  )
+set(check_exes
+  \"$<TARGET_FILE:main>\"
+  )
+")
diff --git a/Tests/RunCMake/BuildDepends/MakeDependencies.step1.cmake b/Tests/RunCMake/BuildDepends/MakeDependencies.step1.cmake
new file mode 100644
index 0000000..c74f033
--- /dev/null
+++ b/Tests/RunCMake/BuildDepends/MakeDependencies.step1.cmake
@@ -0,0 +1,18 @@
+file(TOUCH "${RunCMake_TEST_BINARY_DIR}/main.c")
+foreach(i RANGE 1 20000)
+  file(WRITE "${RunCMake_TEST_BINARY_DIR}/temp_header_file_${i}.h"
+    "#define HEADER_${i} ${i}\n"
+    )
+  file(APPEND "${RunCMake_TEST_BINARY_DIR}/main.c"
+    "#include \"temp_header_file_${i}.h\"\n"
+    )
+endforeach()
+file(APPEND "${RunCMake_TEST_BINARY_DIR}/main.c"
+  "#include \"main.h\"\n"
+  )
+file(APPEND "${RunCMake_TEST_BINARY_DIR}/main.c"
+  "int main(void) { return COUNT; }\n"
+  )
+file(WRITE "${RunCMake_TEST_BINARY_DIR}/main.h"
+  "#define COUNT 1\n"
+  )
diff --git a/Tests/RunCMake/BuildDepends/MakeDependencies.step2.cmake b/Tests/RunCMake/BuildDepends/MakeDependencies.step2.cmake
new file mode 100644
index 0000000..c826d3c
--- /dev/null
+++ b/Tests/RunCMake/BuildDepends/MakeDependencies.step2.cmake
@@ -0,0 +1,3 @@
+file(WRITE "${RunCMake_TEST_BINARY_DIR}/main.h"
+  "#define COUNT 2\n"
+  )
diff --git a/Tests/RunCMake/BuildDepends/RepeatCMake-Custom-Script.cmake b/Tests/RunCMake/BuildDepends/RepeatCMake-Custom-Script.cmake
new file mode 100644
index 0000000..3e953b3
--- /dev/null
+++ b/Tests/RunCMake/BuildDepends/RepeatCMake-Custom-Script.cmake
@@ -0,0 +1,4 @@
+if(EXISTS "${CMAKE_CURRENT_BINARY_DIR}/exists-for-build2")
+  message(FATAL_ERROR "Custom command incorrectly re-ran after CMake re-ran!")
+endif()
+file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/out.txt")
diff --git a/Tests/RunCMake/BuildDepends/RepeatCMake-Custom.cmake b/Tests/RunCMake/BuildDepends/RepeatCMake-Custom.cmake
new file mode 100644
index 0000000..697e485
--- /dev/null
+++ b/Tests/RunCMake/BuildDepends/RepeatCMake-Custom.cmake
@@ -0,0 +1,5 @@
+add_custom_command(OUTPUT out.txt
+  COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_LIST_DIR}/RepeatCMake-Custom-Script.cmake
+  DEPENDS ${CMAKE_CURRENT_LIST_DIR}/RepeatCMake-Custom-Script.cmake
+  )
+add_custom_target(drive ALL DEPENDS out.txt)
diff --git a/Tests/RunCMake/BuildDepends/RunCMakeTest.cmake b/Tests/RunCMake/BuildDepends/RunCMakeTest.cmake
index 1b7b8d9..6232634 100644
--- a/Tests/RunCMake/BuildDepends/RunCMakeTest.cmake
+++ b/Tests/RunCMake/BuildDepends/RunCMakeTest.cmake
@@ -79,6 +79,23 @@
   endif()
 endif()
 
+function(run_RepeatCMake CASE)
+  set(RunCMake_TEST_BINARY_DIR ${RunCMake_BINARY_DIR}/${CASE}-build)
+  if(RunCMake_GENERATOR_IS_MULTI_CONFIG)
+    set(RunCMake_TEST_OPTIONS -DCMAKE_CONFIGURATION_TYPES=Debug)
+  else()
+    set(RunCMake_TEST_OPTIONS -DCMAKE_BUILD_TYPE=Debug)
+  endif()
+  run_cmake(${CASE})
+  set(RunCMake_TEST_NO_CLEAN 1)
+  run_cmake_command(${CASE}-build1 ${CMAKE_COMMAND} --build . --config Debug)
+  run_cmake_command(${CASE}-rerun1 ${CMAKE_COMMAND} .)
+  file(WRITE ${RunCMake_TEST_BINARY_DIR}/exists-for-build2 "")
+  run_cmake_command(${CASE}-build2 ${CMAKE_COMMAND} --build . --config Debug)
+endfunction()
+
+run_RepeatCMake(RepeatCMake-Custom)
+
 function(run_ReGeneration)
   # test re-generation of project even if CMakeLists.txt files disappeared
 
@@ -143,3 +160,7 @@
   run_BuildDepends(CustomCommandDepfile)
   set(run_BuildDepends_skip_step_3 1)
 endif()
+
+if(RunCMake_GENERATOR MATCHES "Make")
+  run_BuildDepends(MakeDependencies)
+endif()
diff --git a/Tests/RunCMake/CommandLine/cmake_depends-check.cmake b/Tests/RunCMake/CommandLine/cmake_depends-check.cmake
index 031478b..e0e3054 100644
--- a/Tests/RunCMake/CommandLine/cmake_depends-check.cmake
+++ b/Tests/RunCMake/CommandLine/cmake_depends-check.cmake
@@ -3,8 +3,9 @@
   file(READ "${depend_make}" depend_make_content)
   string(REGEX REPLACE "\n+$" "" depend_make_content "${depend_make_content}")
   if(NOT depend_make_content MATCHES "
-CMakeFiles/DepTarget.dir/test.c.o: .*/Tests/RunCMake/CommandLine/cmake_depends/test.c
-CMakeFiles/DepTarget.dir/test.c.o: .*/Tests/RunCMake/CommandLine/cmake_depends/test.h$")
+CMakeFiles/DepTarget.dir/test.c.o: \\\\
+ .*/Tests/RunCMake/CommandLine/cmake_depends/test.c \\\\
+ .*/Tests/RunCMake/CommandLine/cmake_depends/test.h$")
     string(REPLACE "\n" "\n  " depend_make_content "  ${depend_make_content}")
     set(RunCMake_TEST_FAILED "depend.make does not have expected content:\n${depend_make_content}")
   endif()
diff --git a/Tests/RunCMake/CommandLine/trace-expand.cmake b/Tests/RunCMake/CommandLine/trace-expand.cmake
index e69de29..24da02a 100644
--- a/Tests/RunCMake/CommandLine/trace-expand.cmake
+++ b/Tests/RunCMake/CommandLine/trace-expand.cmake
@@ -0,0 +1 @@
+set(a [[\B]])
diff --git a/Tests/RunCMake/ExportCompileCommands/Properties.cmake b/Tests/RunCMake/ExportCompileCommands/Properties.cmake
new file mode 100644
index 0000000..c7a38b7
--- /dev/null
+++ b/Tests/RunCMake/ExportCompileCommands/Properties.cmake
@@ -0,0 +1,22 @@
+enable_language(C)
+
+add_library(Unset STATIC empty.c)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+add_library(SetOn STATIC empty.c)
+set(CMAKE_EXPORT_COMPILE_COMMANDS OFF)
+add_library(SetOff STATIC empty.c)
+
+get_property(_set TARGET Unset PROPERTY EXPORT_COMPILE_COMMANDS)
+if(_set)
+  message(SEND_ERROR "EXPORT_COMPILE_COMMANDS property should be unset for Unset target (got \"${_set}\")")
+endif()
+
+get_property(_on TARGET SetOn PROPERTY EXPORT_COMPILE_COMMANDS)
+if(NOT _on STREQUAL "ON")
+  message(SEND_ERROR "EXPORT_COMPILE_COMMANDS property should be \"ON\" for SetOn target (got \"${_on}\")")
+endif()
+
+get_property(_off TARGET SetOff PROPERTY EXPORT_COMPILE_COMMANDS)
+if(NOT _off STREQUAL "OFF")
+  message(SEND_ERROR "EXPORT_COMPILE_COMMANDS property should be \"OFF\" for SetOff target (got \"${_off}\")")
+endif()
diff --git a/Tests/RunCMake/ExportCompileCommands/PropertiesGenerateCommand-check.cmake b/Tests/RunCMake/ExportCompileCommands/PropertiesGenerateCommand-check.cmake
new file mode 100644
index 0000000..d698742
--- /dev/null
+++ b/Tests/RunCMake/ExportCompileCommands/PropertiesGenerateCommand-check.cmake
@@ -0,0 +1,32 @@
+if(NOT EXISTS "${RunCMake_TEST_BINARY_DIR}/compile_commands.json")
+  set(RunCMake_TEST_FAILED "compile_commands.json not generated")
+  return()
+endif()
+
+file(READ "${RunCMake_TEST_BINARY_DIR}/compile_commands.json" compile_commands)
+
+macro(check_error)
+  if(error)
+    message(SEND_ERROR "Unexpected error \"${error}\"\nFor: ${compile_commands}")
+  endif()
+endmacro()
+
+string(JSON num_commands ERROR_VARIABLE error LENGTH "${compile_commands}")
+check_error()
+
+# Only one of the targets has the EXPORT_COMPILE_COMMANDS property enabled.
+if(NOT num_commands STREQUAL 1)
+  message(SEND_ERROR "Expected 1 compile command, got ${num_commands} for ${compile_commands}")
+endif()
+
+# Get the compile command generated.
+string(JSON result ERROR_VARIABLE error GET "${compile_commands}" 0)
+check_error()
+string(JSON result ERROR_VARIABLE error GET "${result}" file)
+check_error()
+
+# And ensure the correct target is in that compile command.
+cmake_path(COMPARE "${result}" EQUAL "${RunCMake_TEST_SOURCE_DIR}/expected_file.c" good)
+if(NOT good)
+  message(SEND_ERROR "Expected \"${result}\" in \"${RunCMake_TEST_SOURCE_DIR}/expected_file.c\"")
+endif()
diff --git a/Tests/RunCMake/ExportCompileCommands/PropertiesGenerateCommand.cmake b/Tests/RunCMake/ExportCompileCommands/PropertiesGenerateCommand.cmake
new file mode 100644
index 0000000..46c8845
--- /dev/null
+++ b/Tests/RunCMake/ExportCompileCommands/PropertiesGenerateCommand.cmake
@@ -0,0 +1,7 @@
+enable_language(C)
+
+add_library(Unset STATIC empty.c)
+add_library(ToBeSet STATIC expected_file.c)
+
+# Only one target with EXPORT_COMPILE_COMMANDS property.
+set_property(TARGET ToBeSet PROPERTY EXPORT_COMPILE_COMMANDS TRUE)
diff --git a/Tests/RunCMake/ExportCompileCommands/RunCMakeTest.cmake b/Tests/RunCMake/ExportCompileCommands/RunCMakeTest.cmake
index 9e7e732..b691637 100644
--- a/Tests/RunCMake/ExportCompileCommands/RunCMakeTest.cmake
+++ b/Tests/RunCMake/ExportCompileCommands/RunCMakeTest.cmake
@@ -1,4 +1,12 @@
 include(RunCMake)
 
+if(RunCMake_GENERATOR_IS_MULTI_CONFIG)
+  set(RunCMake_TEST_OPTIONS -DCMAKE_CONFIGURATION_TYPES=Debug)
+else()
+  set(RunCMake_TEST_OPTIONS -DCMAKE_BUILD_TYPE=Debug)
+endif()
+
 run_cmake_with_options(BeforeProject -DCMAKE_PROJECT_INCLUDE_BEFORE=BeforeProjectBEFORE.cmake)
 run_cmake(CustomCompileRule)
+run_cmake(Properties)
+run_cmake(PropertiesGenerateCommand)
diff --git a/Tests/RunCMake/ExportCompileCommands/expected_file.c b/Tests/RunCMake/ExportCompileCommands/expected_file.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/Tests/RunCMake/ExportCompileCommands/expected_file.c
diff --git a/Tests/RunCMake/ExternalProject/CONFIGURE_HANDLED_BY_BUILD-rebuild-check.cmake b/Tests/RunCMake/ExternalProject/CONFIGURE_HANDLED_BY_BUILD-rebuild-check.cmake
new file mode 100644
index 0000000..887da0f
--- /dev/null
+++ b/Tests/RunCMake/ExternalProject/CONFIGURE_HANDLED_BY_BUILD-rebuild-check.cmake
@@ -0,0 +1,19 @@
+file(TIMESTAMP "${STAMP_DIR}/proj1-configure" PROJ1_CONFIGURE_TIMESTAMP_AFTER "%s")
+# When BUILD_ALWAYS is set, the build stamp is never created.
+file(TIMESTAMP "${STAMP_DIR}/proj2-configure" PROJ2_CONFIGURE_TIMESTAMP_AFTER "%s")
+file(TIMESTAMP "${STAMP_DIR}/proj2-build" PROJ2_BUILD_TIMESTAMP_AFTER "%s")
+
+if(NOT PROJ1_CONFIGURE_TIMESTAMP_BEFORE EQUAL PROJ1_CONFIGURE_TIMESTAMP_AFTER)
+  set(RunCMake_TEST_FAILED "Unexpected rebuild of proj1 configure step (${PROJ1_CONFIGURE_TIMESTAMP_BEFORE} != ${PROJ1_CONFIGURE_TIMESTAMP_AFTER})")
+  return()
+endif()
+
+if(NOT PROJ2_CONFIGURE_TIMESTAMP_BEFORE EQUAL PROJ2_CONFIGURE_TIMESTAMP_AFTER)
+  set(RunCMake_TEST_FAILED "Unexpected rebuild of proj2 configure step (${PROJ2_CONFIGURE_TIMESTAMP_BEFORE} != ${PROJ2_CONFIGURE_TIMESTAMP_AFTER})")
+  return()
+endif()
+
+if(PROJ2_BUILD_TIMESTAMP_BEFORE EQUAL PROJ2_BUILD_TIMESTAMP_AFTER)
+  set(RunCMake_TEST_FAILED "proj2 build step did not rebuild (${PROJ2_BUILD_TIMESTAMP_BEFORE} != ${PROJ2_BUILD_TIMESTAMP_AFTER})")
+  return()
+endif()
diff --git a/Tests/RunCMake/ExternalProject/CONFIGURE_HANDLED_BY_BUILD.cmake b/Tests/RunCMake/ExternalProject/CONFIGURE_HANDLED_BY_BUILD.cmake
new file mode 100644
index 0000000..c86a60e
--- /dev/null
+++ b/Tests/RunCMake/ExternalProject/CONFIGURE_HANDLED_BY_BUILD.cmake
@@ -0,0 +1,28 @@
+include(ExternalProject)
+
+# Given this setup, on the first build, both configure steps and both build
+# steps will run. On a noop rebuild, only the build steps will run. Without
+# CONFIGURE_HANDLED_BY_BUILD, the configure step of proj2 would also run on a
+# noop rebuild.
+
+ExternalProject_Add(proj1
+  DOWNLOAD_COMMAND ""
+  SOURCE_DIR ""
+  CONFIGURE_COMMAND ${CMAKE_COMMAND} -E echo "Doing something"
+  # file(TIMESTAMP) gives back the timestamp in seconds so we sleep a second to
+  # make sure we get a different timestamp on the stamp file
+  BUILD_COMMAND ${CMAKE_COMMAND} -E sleep 1
+  INSTALL_COMMAND ""
+  BUILD_ALWAYS ON
+  STAMP_DIR "stamp"
+)
+ExternalProject_Add(proj2
+  DOWNLOAD_COMMAND ""
+  SOURCE_DIR ""
+  CONFIGURE_COMMAND ${CMAKE_COMMAND} -E echo "Doing something"
+  BUILD_COMMAND ${CMAKE_COMMAND} -E sleep 1
+  INSTALL_COMMAND ""
+  CONFIGURE_HANDLED_BY_BUILD ON
+  DEPENDS proj1
+  STAMP_DIR "stamp"
+)
diff --git a/Tests/RunCMake/ExternalProject/RunCMakeTest.cmake b/Tests/RunCMake/ExternalProject/RunCMakeTest.cmake
index 598671f..22b8d24 100644
--- a/Tests/RunCMake/ExternalProject/RunCMakeTest.cmake
+++ b/Tests/RunCMake/ExternalProject/RunCMakeTest.cmake
@@ -151,3 +151,33 @@
 if(doSubstitutionTest)
     __ep_test_with_build(Substitutions)
 endif()
+
+function(__ep_test_CONFIGURE_HANDLED_BY_BUILD)
+  set(RunCMake_TEST_BINARY_DIR ${RunCMake_BINARY_DIR}/CONFIGURE_HANDLED_BY_BUILD-build)
+  run_cmake(CONFIGURE_HANDLED_BY_BUILD)
+
+  if(RunCMake_GENERATOR_IS_MULTI_CONFIG)
+    set(BUILD_CONFIG --config Debug)
+    set(STAMP_DIR "${RunCMake_TEST_BINARY_DIR}/stamp/Debug")
+  else()
+    set(BUILD_CONFIG "")
+    set(STAMP_DIR "${RunCMake_TEST_BINARY_DIR}/stamp")
+  endif()
+
+  set(RunCMake_TEST_NO_CLEAN 1)
+  run_cmake_command(CONFIGURE_HANDLED_BY_BUILD-build ${CMAKE_COMMAND} --build . ${BUILD_CONFIG})
+
+  # Calculate timestamps before rebuilding so we can compare before and after in
+  # CONFIGURE_HANDLED_BY_BUILD-rebuild-check.cmake
+
+  file(TIMESTAMP "${STAMP_DIR}/proj1-configure" PROJ1_CONFIGURE_TIMESTAMP_BEFORE "%s")
+  # When BUILD_ALWAYS is set, the build stamp is never created.
+  file(TIMESTAMP "${STAMP_DIR}/proj2-configure" PROJ2_CONFIGURE_TIMESTAMP_BEFORE "%s")
+  file(TIMESTAMP "${STAMP_DIR}/proj2-build" PROJ2_BUILD_TIMESTAMP_BEFORE "%s")
+
+  run_cmake_command(CONFIGURE_HANDLED_BY_BUILD-rebuild ${CMAKE_COMMAND} --build . ${BUILD_CONFIG})
+endfunction()
+
+if(NOT RunCMake_GENERATOR MATCHES "Visual Studio 9 ")
+  __ep_test_CONFIGURE_HANDLED_BY_BUILD()
+endif()
diff --git a/Tests/RunCMake/NinjaMultiConfig/PostBuild-debug-in-release-graph-build-stdout.txt b/Tests/RunCMake/NinjaMultiConfig/PostBuild-debug-in-release-graph-build-stdout.txt
new file mode 100644
index 0000000..fad923a
--- /dev/null
+++ b/Tests/RunCMake/NinjaMultiConfig/PostBuild-debug-in-release-graph-build-stdout.txt
@@ -0,0 +1,2 @@
+Running post-build command with Debug
+Generating Debug\.txt
diff --git a/Tests/RunCMake/NinjaMultiConfig/PostBuild-release-build-stdout.txt b/Tests/RunCMake/NinjaMultiConfig/PostBuild-release-build-stdout.txt
new file mode 100644
index 0000000..485a52c
--- /dev/null
+++ b/Tests/RunCMake/NinjaMultiConfig/PostBuild-release-build-stdout.txt
@@ -0,0 +1,3 @@
+Running post-build command with Release
+Generating out\.txt with Release
+Generating Release\.txt
diff --git a/Tests/RunCMake/NinjaMultiConfig/PostBuild.cmake b/Tests/RunCMake/NinjaMultiConfig/PostBuild.cmake
new file mode 100644
index 0000000..5fcff74
--- /dev/null
+++ b/Tests/RunCMake/NinjaMultiConfig/PostBuild.cmake
@@ -0,0 +1,6 @@
+enable_language(C)
+
+add_executable(Exe main.c)
+add_custom_command(TARGET Exe POST_BUILD COMMAND ${CMAKE_COMMAND} -E echo "Running post-build command with $<CONFIG>")
+add_custom_command(TARGET Exe POST_BUILD COMMAND ${CMAKE_COMMAND} -E echo "Generating out.txt with $<CONFIG>" BYPRODUCTS out.txt)
+add_custom_command(TARGET Exe POST_BUILD COMMAND ${CMAKE_COMMAND} -E echo "Generating $<CONFIG>.txt" BYPRODUCTS $<CONFIG>.txt)
diff --git a/Tests/RunCMake/NinjaMultiConfig/RunCMakeTest.cmake b/Tests/RunCMake/NinjaMultiConfig/RunCMakeTest.cmake
index dc2db57..480d628 100644
--- a/Tests/RunCMake/NinjaMultiConfig/RunCMakeTest.cmake
+++ b/Tests/RunCMake/NinjaMultiConfig/RunCMakeTest.cmake
@@ -187,6 +187,12 @@
 run_cmake_build(SimpleCrossConfigs all-all-in-release-graph Release all:all)
 run_cmake_build(SimpleCrossConfigs all-relwithdebinfo-in-release-graph Release all:RelWithDebInfo)
 
+set(RunCMake_TEST_BINARY_DIR ${RunCMake_BINARY_DIR}/PostBuild-build)
+set(RunCMake_TEST_OPTIONS "-DCMAKE_CROSS_CONFIGS=all")
+run_cmake_configure(PostBuild)
+run_cmake_build(PostBuild release Release Exe)
+run_cmake_build(PostBuild debug-in-release-graph Release Exe:Debug)
+
 set(RunCMake_TEST_BINARY_DIR ${RunCMake_BINARY_DIR}/Framework-build)
 set(RunCMake_TEST_OPTIONS "-DCMAKE_CROSS_CONFIGS=all")
 run_cmake_configure(Framework)
diff --git a/Tests/RunCMake/install/FILES-RENAME-all-check.cmake b/Tests/RunCMake/install/FILES-RENAME-all-check.cmake
new file mode 100644
index 0000000..7e9b103
--- /dev/null
+++ b/Tests/RunCMake/install/FILES-RENAME-all-check.cmake
@@ -0,0 +1 @@
+check_installed([[^src;src/script_Debug\.ps]])
diff --git a/Tests/RunCMake/install/FILES-RENAME-bad-result.txt b/Tests/RunCMake/install/FILES-RENAME-bad-result.txt
new file mode 100644
index 0000000..d00491f
--- /dev/null
+++ b/Tests/RunCMake/install/FILES-RENAME-bad-result.txt
@@ -0,0 +1 @@
+1
diff --git a/Tests/RunCMake/install/FILES-RENAME-bad-stderr.txt b/Tests/RunCMake/install/FILES-RENAME-bad-stderr.txt
new file mode 100644
index 0000000..9844158
--- /dev/null
+++ b/Tests/RunCMake/install/FILES-RENAME-bad-stderr.txt
@@ -0,0 +1,6 @@
+CMake Error:
+  Error evaluating generator expression:
+
+    \$<NOTAGENEX>
+
+  Expression did not evaluate to a known generator expression
diff --git a/Tests/RunCMake/install/FILES-RENAME-bad.cmake b/Tests/RunCMake/install/FILES-RENAME-bad.cmake
new file mode 100644
index 0000000..5be0bb2
--- /dev/null
+++ b/Tests/RunCMake/install/FILES-RENAME-bad.cmake
@@ -0,0 +1,4 @@
+install(FILES empty.c
+  DESTINATION mybin
+  RENAME $<NOTAGENEX>
+  )
diff --git a/Tests/RunCMake/install/FILES-RENAME.cmake b/Tests/RunCMake/install/FILES-RENAME.cmake
new file mode 100644
index 0000000..5896e64
--- /dev/null
+++ b/Tests/RunCMake/install/FILES-RENAME.cmake
@@ -0,0 +1,4 @@
+install(FILES script.bat
+  DESTINATION src
+  RENAME script_$<CONFIG>.ps
+  )
diff --git a/Tests/RunCMake/install/RunCMakeTest.cmake b/Tests/RunCMake/install/RunCMakeTest.cmake
index d64d88b..b067b3a 100644
--- a/Tests/RunCMake/install/RunCMakeTest.cmake
+++ b/Tests/RunCMake/install/RunCMakeTest.cmake
@@ -74,6 +74,7 @@
 run_cmake(DIRECTORY-DIRECTORY-bad)
 run_cmake(DIRECTORY-DESTINATION-bad)
 run_cmake(FILES-DESTINATION-bad)
+run_cmake(FILES-RENAME-bad)
 run_cmake(TARGETS-DESTINATION-bad)
 run_cmake(EXPORT-OldIFace)
 run_cmake(EXPORT-UnknownExport)
@@ -91,6 +92,10 @@
 run_cmake(FILES-DESTINATION-TYPE)
 run_cmake(DIRECTORY-DESTINATION-TYPE)
 
+set(RunCMake_TEST_OPTIONS "-DCMAKE_BUILD_TYPE:STRING=Debug")
+run_install_test(FILES-RENAME)
+unset(RunCMake_TEST_OPTIONS)
+
 if(APPLE)
   run_cmake(TARGETS-Apple-Defaults)
 endif()
diff --git a/Tests/RunCMake/list/REMOVE_ITEM-NoItemArg.cmake b/Tests/RunCMake/list/REMOVE_ITEM-NoItemArg.cmake
new file mode 100644
index 0000000..f69c024
--- /dev/null
+++ b/Tests/RunCMake/list/REMOVE_ITEM-NoItemArg.cmake
@@ -0,0 +1,5 @@
+set(ls "a" "b" "c")
+list(REMOVE_ITEM ls alpha)
+if (NOT ls STREQUAL "a;b;c")
+  message(FATAL_ERROR "list(REMOVE_ITEM) modified for empty item")
+endif ()
diff --git a/Tests/RunCMake/list/RunCMakeTest.cmake b/Tests/RunCMake/list/RunCMakeTest.cmake
index b4a91bc..c11891c 100644
--- a/Tests/RunCMake/list/RunCMakeTest.cmake
+++ b/Tests/RunCMake/list/RunCMakeTest.cmake
@@ -30,6 +30,7 @@
 run_cmake(REMOVE_AT-NotList)
 run_cmake(REMOVE_DUPLICATES-NotList)
 run_cmake(REMOVE_ITEM-NotList)
+run_cmake(REMOVE_ITEM-NoItemArg)
 run_cmake(REVERSE-NotList)
 run_cmake(SORT-NotList)
 
diff --git a/Tests/VSWinStorePhone/CMakeLists.txt b/Tests/VSWinStorePhone/CMakeLists.txt
index 56e4c1d..edd4330 100644
--- a/Tests/VSWinStorePhone/CMakeLists.txt
+++ b/Tests/VSWinStorePhone/CMakeLists.txt
@@ -119,13 +119,13 @@
 set_property(SOURCE ${PIXELSHADER_FILES} PROPERTY VS_SHADER_TYPE Pixel)
 set_property(SOURCE ${PIXELSHADER_FILES} PROPERTY VS_SHADER_ENTRYPOINT mainPS)
 set_property(SOURCE ${PIXELSHADER_FILES} PROPERTY VS_SHADER_MODEL 4.0_level_9_3)
-set_property(SOURCE ${PIXELSHADER_FILES} PROPERTY VS_SHADER_FLAGS "/DFLAGS_ADDED")
+set_property(SOURCE ${PIXELSHADER_FILES} PROPERTY VS_SHADER_FLAGS $<1:/DFLAGS_ADDED>)
 set_property(SOURCE ${PIXELSHADER_FILES} PROPERTY VS_SHADER_OUTPUT_HEADER_FILE "$(OutDir)%(Filename).h")
 
 set_property(SOURCE ${VERTEXSHADER_FILES} PROPERTY VS_SHADER_TYPE Vertex)
 set_property(SOURCE ${VERTEXSHADER_FILES} PROPERTY VS_SHADER_ENTRYPOINT mainVS)
 set_property(SOURCE ${VERTEXSHADER_FILES} PROPERTY VS_SHADER_MODEL 4.0_level_9_3)
-set_property(SOURCE ${VERTEXSHADER_FILES} PROPERTY VS_SHADER_FLAGS "/DFLAGS_ADDED")
+set_property(SOURCE ${VERTEXSHADER_FILES} PROPERTY VS_SHADER_FLAGS $<1:/DFLAGS_ADDED>)
 set_property(SOURCE ${VERTEXSHADER_FILES} PROPERTY VS_SHADER_OUTPUT_HEADER_FILE "$(OutDir)%(Filename).h")
 set_property(SOURCE ${VERTEXSHADER_FILES} PROPERTY VS_SETTINGS "$<$<CONFIG:DEBUG>:SourceProperty1=SourceProperty1Value>")
 
diff --git a/Utilities/Release/macos/qt-5.15.2-macosx10.13-x86_64-arm64.bash b/Utilities/Release/macos/qt-5.15.2-macosx10.13-x86_64-arm64.bash
new file mode 100755
index 0000000..bf92e62
--- /dev/null
+++ b/Utilities/Release/macos/qt-5.15.2-macosx10.13-x86_64-arm64.bash
@@ -0,0 +1,125 @@
+#!/usr/bin/env bash
+
+# Run this script on a macOS x86_64 host to generate Qt universal binaries.
+#
+# This script requires the 'makeuniversal' tool from:
+#
+#   https://github.com/fizzyade/makeuniversal
+#
+# Build it with an existing local Qt installation first.
+#
+# Set the PATH environment variable to contain the location of 'makeuniversal'.
+
+set -e
+set -x
+
+umask 022
+
+# Verify that 'makeuniversal' is available in the PATH.
+type -p makeuniversal >/dev/null
+
+# Download, verify, and extract sources.
+curl -OL https://download.qt.io/archive/qt/5.15/5.15.2/single/qt-everywhere-src-5.15.2.tar.xz
+shasum -a 256 qt-everywhere-src-5.15.2.tar.xz | grep -q 3a530d1b243b5dec00bc54937455471aaa3e56849d2593edb8ded07228202240
+tar xjf qt-everywhere-src-5.15.2.tar.xz
+
+# Build the x86_64 variant.
+mkdir qt-5.15.2-x86_64
+cd qt-5.15.2-x86_64
+../qt-everywhere-src-5.15.2/configure \
+  --prefix=/ \
+  -platform macx-clang \
+  -device-option QMAKE_APPLE_DEVICE_ARCHS=x86_64 \
+  -device-option QMAKE_MACOSX_DEPLOYMENT_TARGET=10.13 \
+  -release \
+  -opensource -confirm-license \
+  -gui \
+  -widgets \
+  -no-gif \
+  -no-icu \
+  -no-pch \
+  -no-angle \
+  -no-opengl \
+  -no-dbus \
+  -no-harfbuzz \
+  -skip declarative \
+  -skip multimedia \
+  -skip qtcanvas3d \
+  -skip qtcharts \
+  -skip qtconnectivity \
+  -skip qtdeclarative \
+  -skip qtgamepad \
+  -skip qtlocation \
+  -skip qtmultimedia \
+  -skip qtnetworkauth \
+  -skip qtpurchasing \
+  -skip qtremoteobjects \
+  -skip qtscript \
+  -skip qtsensors \
+  -skip qtserialbus \
+  -skip qtserialport \
+  -skip qtsvg \
+  -skip qtwebchannel \
+  -skip qtwebengine \
+  -skip qtwebsockets \
+  -skip qtxmlpatterns \
+  -nomake examples \
+  -nomake tests \
+  -nomake tools
+make -j 8
+cd ..
+
+# Build the arm64 variant.
+mkdir qt-5.15.2-arm64
+cd qt-5.15.2-arm64
+../qt-everywhere-src-5.15.2/configure \
+  --prefix=/ \
+  -platform macx-clang \
+  -device-option QMAKE_APPLE_DEVICE_ARCHS=arm64 \
+  -device-option QMAKE_MACOSX_DEPLOYMENT_TARGET=10.13 \
+  -release \
+  -opensource -confirm-license \
+  -gui \
+  -widgets \
+  -no-gif \
+  -no-icu \
+  -no-pch \
+  -no-angle \
+  -no-opengl \
+  -no-dbus \
+  -no-harfbuzz \
+  -skip declarative \
+  -skip multimedia \
+  -skip qtcanvas3d \
+  -skip qtcharts \
+  -skip qtconnectivity \
+  -skip qtdeclarative \
+  -skip qtgamepad \
+  -skip qtlocation \
+  -skip qtmultimedia \
+  -skip qtnetworkauth \
+  -skip qtpurchasing \
+  -skip qtremoteobjects \
+  -skip qtscript \
+  -skip qtsensors \
+  -skip qtserialbus \
+  -skip qtserialport \
+  -skip qtsvg \
+  -skip qtwebchannel \
+  -skip qtwebengine \
+  -skip qtwebsockets \
+  -skip qtxmlpatterns \
+  -nomake examples \
+  -nomake tests \
+  -nomake tools
+make -j 8 -k
+cd ..
+
+# Combine the two builds into universal binaries.
+makeuniversal qt-5.15.2-univ qt-5.15.2-x86_64 qt-5.15.2-arm64
+cd qt-5.15.2-univ
+make install -j 8 INSTALL_ROOT=/tmp/qt-5.15.2-macosx10.13-x86_64-arm64
+cd ..
+
+# Create the final tarball containing universal binaries.
+tar cjf qt-5.15.2-macosx10.13-x86_64-arm64.tar.xz -C /tmp qt-5.15.2-macosx10.13-x86_64-arm64
diff --git a/Utilities/Release/macos/qt-5.9.9-macosx10.10-x86_64-arm64.bash b/Utilities/Release/macos/qt-5.9.9-macosx10.10-x86_64-arm64.bash
index a61e114..79931ec 100755
--- a/Utilities/Release/macos/qt-5.9.9-macosx10.10-x86_64-arm64.bash
+++ b/Utilities/Release/macos/qt-5.9.9-macosx10.10-x86_64-arm64.bash
@@ -13,6 +13,8 @@
 set -e
 set -x
 
+umask 022
+
 # Verify that 'makeuniversal' is available in the PATH.
 type -p makeuniversal >/dev/null
 
diff --git a/Utilities/cmjsoncpp/src/lib_json/json_reader.cpp b/Utilities/cmjsoncpp/src/lib_json/json_reader.cpp
index 6eeba0e..8362fc4 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 @@
 // 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 @@
 // //////////////////////////////////////////////////////////////////
 
 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 @@
   // 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);
+  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 = readValue();
+  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;
-    } // 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 tokenArrayBegin:
+      successful = this->readArray(token);
+      this->currentValue().setOffsetLimit(this->current_ - this->begin_);
+      break;
+    case tokenNumber:
+      successful = this->decodeNumber(token);
+      break;
+    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 @@
     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 @@
   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 @@
   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 @@
   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 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 @@
       // 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 @@
   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 @@
       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 @@
   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 @@
     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 @@
   ++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 @@
   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 @@
     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 @@
   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 @@
 
   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 @@
 }
 
 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);
+  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 = readValue();
+  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;
-    } // 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 tokenArrayBegin:
+      successful = this->readArray(token);
+      this->currentValue().setOffsetLimit(this->current_ - this->begin_);
+      break;
+    case tokenNumber:
+      successful = this->decodeNumber(token);
+      break;
+    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 {
+      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 'I':
-    if (features_.allowSpecialFloats_) {
-      token.type_ = tokenPosInf;
-      ok = 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;
+      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 @@
     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 @@
   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 @@
   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 @@
   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 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 @@
       // 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 @@
   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 @@
 
   // 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 @@
   }
 
   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 @@
       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 @@
   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 @@
     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 @@
   ++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 @@
 
 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 @@
 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 @@
   (*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 @@
   (*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 @@
   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 f271e57..eadb1c3 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 @@
 // 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 @@
 
 #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 @@
  *               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 @@
 
   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 @@
 
 /* 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 @@
     *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 @@
   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 @@
 // //////////////////////////////////////////////////////////////////
 #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 @@
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
 
-Value::CommentInfo::CommentInfo() : comment_(0)
-{}
-
-Value::CommentInfo::~CommentInfo() {
-  if (comment_)
-    releaseStringValue(comment_, 0u);
+Value::CommentInfo::CommentInfo()
+  : comment_(0)
+{
 }
 
-void Value::CommentInfo::setComment(const char* text, size_t len) {
-  if (comment_) {
-    releaseStringValue(comment_, 0u);
-    comment_ = 0;
+Value::CommentInfo::~CommentInfo()
+{
+  if (this->comment_)
+    releaseStringValue(this->comment_, 0u);
+}
+
+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 @@
 // 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(char const* str, unsigned ulength, DuplicationPolicy allocate)
-    : cstr_(str) {
-  // allocate != duplicate
-  storage_.policy_ = allocate & 0x3;
-  storage_.length_ = ulength & 0x3FFFFFFF;
+Value::CZString::CZString(ArrayIndex aindex)
+  : cstr_(0)
+  , index_(aindex)
+{
 }
 
-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(char const* str, unsigned ulength,
+                          DuplicationPolicy allocate)
+  : cstr_(str)
+{
+  // allocate != duplicate
+  this->storage_.policy_ = allocate & 0x3;
+  this->storage_.length_ = ulength & 0x3FFFFFFF;
+}
+
+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 @@
  * 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_)
+  : 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;
+  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 @@
   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(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 @@
 //   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 @@
 //
 //# 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 @@
       // 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 @@
   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 @@
   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 @@
 // 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 @@
   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 @@
     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 @@
       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 @@
   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 @@
   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 fc86505..803cfab 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)))
+#  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 <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 @@
 #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 @@
   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 @@
   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 @@
 
 #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 @@
     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 @@
   } 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) { 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 @@
   // 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 @@
 }
 
 // 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 @@
   }
   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 @@
   // 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 @@
 
 // Class Writer
 // //////////////////////////////////////////////////////////////////
-Writer::~Writer() {}
+Writer::~Writer()
+{
+}
 
 // Class FastWriter
 // //////////////////////////////////////////////////////////////////
 
 FastWriter::FastWriter()
-    : yamlCompatiblityEnabled_(false), dropNullPlaceholders_(false),
-      omitEndingLineFeed_(false) {}
-
-void FastWriter::enableYAMLCompatibility() { yamlCompatiblityEnabled_ = true; }
-
-void FastWriter::dropNullPlaceholders() { dropNullPlaceholders_ = true; }
-
-void FastWriter::omitEndingLineFeed() { omitEndingLineFeed_ = true; }
-
-JSONCPP_STRING FastWriter::write(const Value& root) {
-  document_.clear();
-  writeValue(root);
-  if (!omitEndingLineFeed_)
-    document_ += "\n";
-  return document_;
+  : yamlCompatiblityEnabled_(false)
+  , dropNullPlaceholders_(false)
+  , omitEndingLineFeed_(false)
+{
 }
 
-void FastWriter::writeValue(const Value& value) {
+void FastWriter::enableYAMLCompatibility()
+{
+  this->yamlCompatiblityEnabled_ = true;
+}
+
+void FastWriter::dropNullPlaceholders()
+{
+  this->dropNullPlaceholders_ = true;
+}
+
+void FastWriter::omitEndingLineFeed()
+{
+  this->omitEndingLineFeed_ = true;
+}
+
+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)
+{
   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]);
+    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 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]);
-    }
-    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 @@
 // //////////////////////////////////////////////////////////////////
 
 StyledWriter::StyledWriter()
-    : 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_;
+  : rightMargin_(74)
+  , indentSize_(3)
+  , addChildValues_()
+{
 }
 
-void StyledWriter::writeValue(const Value& value) {
+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)
+{
   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;
-        }
-        document_ += ',';
-        writeCommentAfterValueOnSameLine(childValue);
-      }
-      unindent();
-      writeWithIndent("}");
+    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;
     }
-  } 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);
+        }
+        this->unindent();
+        this->writeWithIndent("}");
+      }
+    } 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::unindent() {
-  assert(indentString_.size() >= indentSize_);
-  indentString_.resize(indentString_.size() - indentSize_);
+void StyledWriter::indent()
+{
+  this->indentString_ += JSONCPP_STRING(this->indentSize_, ' ');
 }
 
-void StyledWriter::writeCommentBeforeValue(const Value& root) {
+void StyledWriter::unindent()
+{
+  assert(this->indentString_.size() >= this->indentSize_);
+  this->indentString_.resize(this->indentString_.size() - this->indentSize_);
+}
+
+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.
+  : document_(NULL)
+  , rightMargin_(74)
+  , indentation_(indentation)
+  , addChildValues_()
+{
 }
 
-void StyledStreamWriter::writeValue(const Value& value) {
+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;
-        }
-        *document_ << ",";
-        writeCommentAfterValueOnSameLine(childValue);
-      }
-      unindent();
-      writeWithIndent("}");
+    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;
     }
-  } 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);
+        }
+        this->unindent();
+        this->writeWithIndent("}");
+      }
+    } 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::unindent() {
-  assert(indentString_.size() >= indentation_.size());
-  indentString_.resize(indentString_.size() - indentation_.size());
+void StyledStreamWriter::indent()
+{
+  this->indentString_ += this->indentation_;
 }
 
-void StyledStreamWriter::writeCommentBeforeValue(const Value& root) {
+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)
+{
   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 @@
   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 @@
 }
 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;
-        }
-        *sout_ << ",";
-        writeCommentAfterValueOnSameLine(childValue);
-      }
-      unindent();
-      writeWithIndent("}");
+    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;
     }
-  } 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);
+        }
+        this->unindent();
+        this->writeWithIndent("}");
+      }
+    } 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::unindent() {
-  assert(indentString_.size() >= indentation_.size());
-  indentString_.resize(indentString_.size() - indentation_.size());
+void BuiltStyledStreamWriter::indent()
+{
+  this->indentString_ += this->indentation_;
 }
 
-void BuiltStyledStreamWriter::writeCommentBeforeValue(Value const& root) {
-  if (cs_ == CommentStyle::None) return;
+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 (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 @@
   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 @@
 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 @@
   //! [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);